◉ AI Models/2026-04-10Advanced

Building an AI Personalization Engine with Rork Max — Adaptive UI, Smart Content Ranking, and Notification Timing That Learns from Every User

An advanced guide to building an AI-powered personalization engine in Rork Max. Learn how to collect user behavior data, build real-time learning pipelines, dynamically optimize UI layouts and content delivery, and automate notification timing — with the production lessons I learned running wallpaper and calming-tone apps solo for over a decade.

Rork Max²³⁶ AI³¹personalizationmachine learningUX optimizationReact Native²³⁹ Supabase³⁷ real-time⁴user experience

✦ Premium Article

Making People Feel the App Was Built Just for Them

Thousands of new apps hit the app stores every day. When feature parity makes differentiation nearly impossible, the apps that win are the ones that make every user feel like the experience was built just for them. That feeling — personalization — is now the single biggest driver of retention.

As an indie app developer, I've run small wallpaper, calming-tone, and intention apps solo for years. Now that features alone rarely set an app apart, the thing I find moves retention most is a small, tactile sense that the app was prepared for you. What once needed teams of data scientists is now within reach for a single developer when you pair Rork Max with AI APIs. This guide walks the design — from learning behavior to adapting UI layout, content order, and notification timing — and then shares, concretely, the mistakes I hit in production and how I avoided them.

This article walks you through the complete architecture: data collection, AI-powered analysis, dynamic UI adaptation, smart content ranking, and intelligent notification scheduling. It's an advanced guide — you should be comfortable with Rork Max basics, React Native state management, and Supabase fundamentals before diving in. If you're just getting started, check out the Rork AI Prompt Engineering Mastery Guide first.

Architecting the Personalization Engine

The AI personalization engine consists of four distinct layers, each with a clear responsibility.

Data Collection Layer (Event Tracking)

Every meaningful user action becomes an event: taps, scrolls, screen dwell time, search queries, feature usage frequency. This raw behavioral data feeds the learning pipeline.

Intelligence Layer (Analysis & Learning)

Collected data flows into an analysis pipeline where AI (Claude API or Gemini API) extracts behavioral patterns that rule-based systems can't detect. This layer builds and continuously updates user preference profiles.

Decision Layer

Based on learning results, this layer determines what each user should see. It decides UI component ordering, content priorities, and notification timing and content — all the personalization logic converges here.

Delivery Layer

Decisions get applied to the app UI in real time, integrating with React Native's state management to deliver personalized experiences without visual glitches or layout shifts.

// Core structure of the personalization engine
// personalization-engine.ts
 
import { createClient } from '@supabase/supabase-js';
 
// Type definitions
interface UserProfile {
  userId: string;
  segments: string[];           // User segments
  preferences: Record<string, number>; // Preference scores
  engagementPattern: {
    peakHours: number[];        // Active hours
    avgSessionDuration: number; // Average session length
    favoriteFeatures: string[]; // Most-used features
  };
  lastUpdated: string;
}
 
interface PersonalizationDecision {
  uiLayout: string;             // UI layout pattern
  contentOrder: string[];       // Content display order
  highlightedFeatures: string[]; // Features to emphasize
  notificationSchedule: {
    nextSendTime: string;       // Next notification time
    messageTemplate: string;    // Message template ID
  };
}
 
class PersonalizationEngine {
  private supabase;
  private cache: Map<string, UserProfile> = new Map();
 
  constructor(supabaseUrl: string, supabaseKey: string) {
    this.supabase = createClient(supabaseUrl, supabaseKey);
  }
 
  // Get user profile with caching
  async getUserProfile(userId: string): Promise<UserProfile> {
    if (this.cache.has(userId)) {
      const cached = this.cache.get(userId)\!;
      const age = Date.now() - new Date(cached.lastUpdated).getTime();
      if (age < 5 * 60 * 1000) return cached; // 5-minute cache
    }
 
    const { data } = await this.supabase
      .from('user_profiles')
      .select('*')
      .eq('user_id', userId)
      .single();
 
    if (data) {
      this.cache.set(userId, data);
      return data;
    }
 
    // Default profile for new users
    return this.createDefaultProfile(userId);
  }
 
  // Execute personalization decision
  async decide(userId: string): Promise<PersonalizationDecision> {
    const profile = await this.getUserProfile(userId);
    return this.generateDecision(profile);
  }
 
  private createDefaultProfile(userId: string): UserProfile {
    return {
      userId,
      segments: ['new_user'],
      preferences: {},
      engagementPattern: {
        peakHours: [],
        avgSessionDuration: 0,
        favoriteFeatures: [],
      },
      lastUpdated: new Date().toISOString(),
    };
  }
 
  private generateDecision(profile: UserProfile): PersonalizationDecision {
    return {
      uiLayout: this.selectLayout(profile),
      contentOrder: this.rankContent(profile),
      highlightedFeatures: this.selectFeatures(profile),
      notificationSchedule: this.scheduleNotification(profile),
    };
  }
}
 
export default PersonalizationEngine;

✦

Thank you for reading this far.

Continue Reading

What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.

WHAT YOU'LL LEARN

✦Why personalizing on day one dropped Day 1 retention from 42% to 34%, and the 3-session hold that recovered it to 44%

✦How calling the AI every session pushed monthly API cost from ¥9,000 to ¥38,000 — and the threshold-batch throttle that fixed it

✦Retiming notifications to the median recent open hour to lift open rate from 4.8% to 9.1%, with the code

Secure payment via Stripe · Cancel anytime

✦

Unlock This Article

Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.

Unlock all articles with Membership →

Building the User Behavior Data Collection Pipeline

Personalization accuracy depends directly on data quality and volume. Here's how to build an effective event tracking system while respecting user privacy.

Designing the Event Tracking System

The key principle is selective tracking — record only events that directly feed personalization decisions, not everything.

// event-tracker.ts — Behavioral data collection module
 
type EventCategory = 'navigation' | 'interaction' | 'content' | 'commerce';
 
interface TrackingEvent {
  eventName: string;
  category: EventCategory;
  properties: Record<string, any>;
  timestamp: number;
  sessionId: string;
}
 
class EventTracker {
  private buffer: TrackingEvent[] = [];
  private readonly FLUSH_INTERVAL = 30000;  // Batch send every 30s
  private readonly BUFFER_SIZE = 50;         // Flush at 50 events
  private sessionId: string;
 
  constructor(private supabase: any, private userId: string) {
    this.sessionId = this.generateSessionId();
    this.startAutoFlush();
  }
 
  // Track screen navigation
  trackScreenView(screenName: string, params?: Record<string, any>) {
    this.addEvent({
      eventName: 'screen_view',
      category: 'navigation',
      properties: { screenName, ...params },
      timestamp: Date.now(),
      sessionId: this.sessionId,
    });
  }
 
  // Track user interactions
  trackInteraction(
    element: string,
    action: 'tap' | 'long_press' | 'swipe' | 'scroll',
    context?: Record<string, any>
  ) {
    this.addEvent({
      eventName: 'user_interaction',
      category: 'interaction',
      properties: { element, action, ...context },
      timestamp: Date.now(),
      sessionId: this.sessionId,
    });
  }
 
  // Track content engagement
  trackContentEngagement(
    contentId: string,
    contentType: string,
    engagementMs: number,
    scrollDepth: number
  ) {
    this.addEvent({
      eventName: 'content_engagement',
      category: 'content',
      properties: { contentId, contentType, engagementMs, scrollDepth },
      timestamp: Date.now(),
      sessionId: this.sessionId,
    });
  }
 
  // Track search behavior
  trackSearch(query: string, resultCount: number, selectedIndex?: number) {
    this.addEvent({
      eventName: 'search',
      category: 'interaction',
      properties: { query, resultCount, selectedIndex },
      timestamp: Date.now(),
      sessionId: this.sessionId,
    });
  }
 
  private addEvent(event: TrackingEvent) {
    this.buffer.push(event);
    if (this.buffer.length >= this.BUFFER_SIZE) {
      this.flush();
    }
  }
 
  // Send buffered events to Supabase
  private async flush() {
    if (this.buffer.length === 0) return;
 
    const events = [...this.buffer];
    this.buffer = [];
 
    try {
      await this.supabase.from('user_events').insert(
        events.map(e => ({
          user_id: this.userId,
          event_name: e.eventName,
          category: e.category,
          properties: e.properties,
          session_id: e.sessionId,
          created_at: new Date(e.timestamp).toISOString(),
        }))
      );
    } catch (error) {
      // On failure, return events to buffer for retry
      this.buffer = [...events, ...this.buffer];
      console.warn('Event flush failed, will retry:', error);
    }
  }
 
  private startAutoFlush() {
    setInterval(() => this.flush(), this.FLUSH_INTERVAL);
  }
 
  private generateSessionId(): string {
    return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
  }
}
 
export default EventTracker;

Supabase Schema Design

An efficient table structure for storing and querying behavioral data:

-- User events table
CREATE TABLE user_events (
  id BIGSERIAL PRIMARY KEY,
  user_id UUID NOT NULL REFERENCES auth.users(id),
  event_name TEXT NOT NULL,
  category TEXT NOT NULL,
  properties JSONB DEFAULT '{}',
  session_id TEXT NOT NULL,
  created_at TIMESTAMPTZ DEFAULT NOW()
);
 
-- Indexes for query performance
CREATE INDEX idx_events_user_time ON user_events (user_id, created_at DESC);
CREATE INDEX idx_events_category ON user_events (category, event_name);
 
-- User profiles table (stores AI analysis results)
CREATE TABLE user_profiles (
  user_id UUID PRIMARY KEY REFERENCES auth.users(id),
  segments TEXT[] DEFAULT ARRAY['new_user'],
  preferences JSONB DEFAULT '{}',
  engagement_pattern JSONB DEFAULT '{}',
  personalization_config JSONB DEFAULT '{}',
  last_updated TIMESTAMPTZ DEFAULT NOW(),
  created_at TIMESTAMPTZ DEFAULT NOW()
);
 
-- Row Level Security
ALTER TABLE user_events ENABLE ROW LEVEL SECURITY;
ALTER TABLE user_profiles ENABLE ROW LEVEL SECURITY;
 
CREATE POLICY "Users can insert own events"
  ON user_events FOR INSERT
  WITH CHECK (auth.uid() = user_id);
 
CREATE POLICY "Users can read own profile"
  ON user_profiles FOR SELECT
  USING (auth.uid() = user_id);

Privacy and Data Minimization

When collecting data for personalization, adhere strictly to these principles. Data minimization: only collect what directly serves personalization. If precise location isn't needed, region-level data is sufficient. Transparency: clearly state in your privacy policy what data you collect and why. On iOS, implement the ATT (App Tracking Transparency) framework. Data expiration: regularly archive or purge old event data. Thirty days of behavioral data is typically sufficient for effective personalization.

AI-Powered User Segmentation and Preference Analysis

The intelligence layer transforms raw behavioral data into actionable user profiles. This is the heart of the personalization engine.

Analyzing Behavior with Claude API

// user-analyzer.ts — AI analysis module
 
interface AnalysisResult {
  segments: string[];
  preferences: Record<string, number>;
  insights: string[];
  recommendedActions: string[];
}
 
class UserAnalyzer {
  private readonly CLAUDE_API_URL = 'https://api.anthropic.com/v1/messages';
 
  constructor(private apiKey: string) {}
 
  async analyzeUserBehavior(
    events: any[],
    currentProfile: any
  ): Promise<AnalysisResult> {
    const eventSummary = this.summarizeEvents(events);
 
    const response = await fetch(this.CLAUDE_API_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': this.apiKey,
        'anthropic-version': '2023-06-01',
      },
      body: JSON.stringify({
        model: 'claude-sonnet-4-6',
        max_tokens: 1024,
        messages: [{
          role: 'user',
          content: `Analyze the following user behavior data and extract actionable personalization insights.
 
## User Behavior Summary (Last 7 Days)
${JSON.stringify(eventSummary, null, 2)}
 
## Current Profile
${JSON.stringify(currentProfile, null, 2)}
 
Respond in this JSON format:
{
  "segments": ["segment_name"],
  "preferences": {"category": score_0_to_1},
  "insights": ["behavioral patterns discovered"],
  "recommendedActions": ["recommended personalization actions"]
}`
        }],
      }),
    });
 
    const data = await response.json();
    return JSON.parse(data.content[0].text);
  }
 
  private summarizeEvents(events: any[]) {
    const screenViews: Record<string, number> = {};
    const interactions: Record<string, number> = {};
    const contentEngagement: Record<string, number> = {};
    let totalSessions = new Set<string>();
    let totalEngagementMs = 0;
 
    for (const event of events) {
      totalSessions.add(event.session_id);
 
      switch (event.event_name) {
        case 'screen_view':
          const screen = event.properties.screenName;
          screenViews[screen] = (screenViews[screen] || 0) + 1;
          break;
        case 'user_interaction':
          const action = `${event.properties.element}:${event.properties.action}`;
          interactions[action] = (interactions[action] || 0) + 1;
          break;
        case 'content_engagement':
          const content = event.properties.contentType;
          contentEngagement[content] = (contentEngagement[content] || 0) + 1;
          totalEngagementMs += event.properties.engagementMs || 0;
          break;
      }
    }
 
    return {
      totalEvents: events.length,
      uniqueSessions: totalSessions.size,
      totalEngagementMinutes: Math.round(totalEngagementMs / 60000),
      screenViews: Object.entries(screenViews)
        .sort(([,a], [,b]) => b - a).slice(0, 10),
      topInteractions: Object.entries(interactions)
        .sort(([,a], [,b]) => b - a).slice(0, 10),
      contentPreferences: Object.entries(contentEngagement)
        .sort(([,a], [,b]) => b - a),
    };
  }
}
 
export default UserAnalyzer;

Segment Definitions and Scoring

Based on AI analysis results, users are automatically classified into segments.

Behavioral segments: power_user (daily usage, 5+ features), casual_user (2-3 times per week, basic features), explorer (actively tries new features), focused_user (concentrates on specific features).

Lifecycle segments: new_user (within 7 days of first launch), activated (used core features 3+ times), retained (14+ days of continuous use), at_risk (usage frequency dropped 50%+), dormant (14+ days inactive).

Preference scores: Each content category receives a 0-to-1 score, calculated as a weighted average of screen dwell time, interaction frequency, and content consumption volume.

// segment-classifier.ts — Hybrid rule-based + AI classification
 
function classifyLifecycleSegment(
  firstSeenAt: Date,
  recentEvents: any[],
  historicalAvg: number
): string {
  const daysSinceFirstSeen =
    (Date.now() - firstSeenAt.getTime()) / (1000 * 60 * 60 * 24);
 
  const lastEventTime = recentEvents.length > 0
    ? new Date(recentEvents[0].created_at).getTime()
    : 0;
  const daysSinceLastEvent = (Date.now() - lastEventTime) / (1000 * 60 * 60 * 24);
 
  if (daysSinceLastEvent > 14) return 'dormant';
  if (daysSinceFirstSeen <= 7) return 'new_user';
 
  const recentWeekEvents = recentEvents.filter(e => {
    const age = (Date.now() - new Date(e.created_at).getTime()) / (1000 * 60 * 60 * 24);
    return age <= 7;
  }).length;
 
  if (historicalAvg > 0 && recentWeekEvents < historicalAvg * 0.5) {
    return 'at_risk';
  }
 
  const coreFeatureUses = recentEvents.filter(e =>
    e.properties?.isCoreFeat === true
  ).length;
 
  if (daysSinceFirstSeen > 14 && coreFeatureUses >= 3) return 'retained';
  if (coreFeatureUses >= 3) return 'activated';
 
  return 'new_user';
}

Dynamic UI Layout Personalization

With user segments and preference scores in hand, the next step is dynamically adapting the app's UI layout per user.

Combining with Server-Driven UI

The personalization engine's decisions drive which sections appear on the home screen and in what order.

// PersonalizedHomeScreen.tsx
 
import React, { useEffect, useState } from 'react';
import { ScrollView, View, Text, ActivityIndicator } from 'react-native';
import { usePersonalization } from '../hooks/usePersonalization';
 
const SECTION_COMPONENTS: Record<string, React.ComponentType<any>> = {
  hero_banner: HeroBanner,
  recent_activity: RecentActivity,
  recommended_content: RecommendedContent,
  trending_items: TrendingItems,
  quick_actions: QuickActions,
  discovery_feed: DiscoveryFeed,
  achievement_progress: AchievementProgress,
};
 
export default function PersonalizedHomeScreen() {
  const { decision, isLoading } = usePersonalization();
 
  if (isLoading) {
    return (
      <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
        <ActivityIndicator size="large" />
      </View>
    );
  }
 
  const sections = decision?.contentOrder || [
    'hero_banner',
    'quick_actions',
    'recent_activity',
    'recommended_content',
  ];
 
  return (
    <ScrollView style={{ flex: 1 }}>
      {sections.map((sectionId, index) => {
        const Component = SECTION_COMPONENTS[sectionId];
        if (\!Component) return null;
        return (
          <View key={`${sectionId}-${index}`}>
            <Component
              userId={decision?.userId}
              preferences={decision?.preferences}
            />
          </View>
        );
      })}
    </ScrollView>
  );
}

Custom Hook for Personalization State

// hooks/usePersonalization.ts
 
import { useEffect, useState, useCallback } from 'react';
import PersonalizationEngine from '../services/personalization-engine';
import AsyncStorage from '@react-native-async-storage/async-storage';
 
export function usePersonalization() {
  const [decision, setDecision] = useState<PersonalizationDecision | null>(null);
  const [isLoading, setIsLoading] = useState(true);
 
  const engine = PersonalizationEngine.getInstance();
 
  const fetchDecision = useCallback(async () => {
    try {
      // Show cached decision first (TTFP optimization)
      const cached = await AsyncStorage.getItem('personalization_decision');
      if (cached) {
        setDecision(JSON.parse(cached));
        setIsLoading(false);
      }
 
      // Fetch fresh decision in background
      const userId = await getCurrentUserId();
      const freshDecision = await engine.decide(userId);
      setDecision(freshDecision);
 
      await AsyncStorage.setItem(
        'personalization_decision',
        JSON.stringify(freshDecision)
      );
    } catch (error) {
      console.warn('Personalization fetch failed:', error);
      setDecision(getDefaultDecision());
    } finally {
      setIsLoading(false);
    }
  }, []);
 
  useEffect(() => {
    fetchDecision();
  }, [fetchDecision]);
 
  return { decision, isLoading, refresh: fetchDecision };
}
 
function getDefaultDecision(): PersonalizationDecision {
  return {
    uiLayout: 'default',
    contentOrder: ['hero_banner', 'quick_actions', 'recent_activity', 'recommended_content'],
    highlightedFeatures: [],
    notificationSchedule: { nextSendTime: '', messageTemplate: '' },
  };
}

A/B Testing Integration

To quantitatively measure personalization effectiveness, integrate with an A/B testing framework.

// ab-test-integration.ts
 
interface Experiment {
  id: string;
  name: string;
  variants: {
    id: string;
    weight: number;
    layoutOverride?: Partial<PersonalizationDecision>;
  }[];
}
 
class ABTestManager {
  private assignments: Map<string, string> = new Map();
 
  // Assign user to variant using deterministic hashing
  assignVariant(userId: string, experiment: Experiment): string {
    const key = `${userId}:${experiment.id}`;
 
    if (this.assignments.has(key)) {
      return this.assignments.get(key)\!;
    }
 
    const hash = this.simpleHash(key);
    const normalized = (hash % 1000) / 1000;
 
    let cumWeight = 0;
    for (const variant of experiment.variants) {
      cumWeight += variant.weight;
      if (normalized < cumWeight) {
        this.assignments.set(key, variant.id);
        return variant.id;
      }
    }
 
    const fallback = experiment.variants[0].id;
    this.assignments.set(key, fallback);
    return fallback;
  }
 
  applyExperiment(
    decision: PersonalizationDecision,
    experiment: Experiment,
    variantId: string
  ): PersonalizationDecision {
    const variant = experiment.variants.find(v => v.id === variantId);
    if (\!variant?.layoutOverride) return decision;
    return { ...decision, ...variant.layoutOverride };
  }
 
  private simpleHash(str: string): number {
    let hash = 0;
    for (let i = 0; i < str.length; i++) {
      const char = str.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash |= 0;
    }
    return Math.abs(hash);
  }
}

Real-Time Content Delivery Optimization

Beyond static personalization, the engine adapts content ordering based on what the user is doing right now in their current session.

Real-Time Scoring Engine

// realtime-scorer.ts
 
interface ContentItem {
  id: string;
  type: string;
  category: string;
  tags: string[];
  freshness: number;        // Days since publication
  globalPopularity: number; // Overall popularity score
}
 
class RealtimeScorer {
  private sessionInteractions: Map<string, number> = new Map();
 
  recordInteraction(contentId: string, weight: number = 1) {
    const current = this.sessionInteractions.get(contentId) || 0;
    this.sessionInteractions.set(contentId, current + weight);
  }
 
  scoreContent(item: ContentItem, userProfile: UserProfile): number {
    let score = 0;
 
    // 1. User preference match (weight: 40%)
    const prefScore = userProfile.preferences[item.category] || 0.5;
    score += prefScore * 0.4;
 
    // 2. Freshness score (weight: 20%)
    const freshnessScore = Math.max(0, 1 - item.freshness / 30);
    score += freshnessScore * 0.2;
 
    // 3. Global popularity (weight: 15%)
    score += item.globalPopularity * 0.15;
 
    // 4. In-session context (weight: 15%)
    const categoryInteractions = Array.from(this.sessionInteractions.entries())
      .filter(([id]) => id.startsWith(item.category))
      .reduce((sum, [, count]) => sum + count, 0);
    const contextScore = Math.min(1, categoryInteractions * 0.2);
    score += contextScore * 0.15;
 
    // 5. Diversity bonus (weight: 10%)
    const diversityBonus = categoryInteractions > 5 ? -0.1 : 0.1;
    score += diversityBonus * 0.1;
 
    return Math.max(0, Math.min(1, score));
  }
 
  rankContent(items: ContentItem[], userProfile: UserProfile): ContentItem[] {
    return items
      .map(item => ({ item, score: this.scoreContent(item, userProfile) }))
      .sort((a, b) => b.score - a.score)
      .map(({ item }) => item);
  }
}

Supabase Edge Function for Recommendations

Server-side scoring with edge delivery for fast response times:

// supabase/functions/personalize-content/index.ts
 
import { serve } from 'https://deno.land/std@0.168.0/http/server.ts';
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2';
 
serve(async (req) => {
  const { userId, context } = await req.json();
 
  const supabase = createClient(
    Deno.env.get('SUPABASE_URL')\!,
    Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')\!
  );
 
  const { data: profile } = await supabase
    .from('user_profiles')
    .select('*')
    .eq('user_id', userId)
    .single();
 
  const { data: recentEvents } = await supabase
    .from('user_events')
    .select('*')
    .eq('user_id', userId)
    .gte('created_at', new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString())
    .order('created_at', { ascending: false })
    .limit(100);
 
  const { data: contentItems } = await supabase
    .from('content')
    .select('*')
    .eq('status', 'published')
    .order('created_at', { ascending: false })
    .limit(50);
 
  const rankedContent = personalizeContent(
    contentItems || [], profile, recentEvents || [], context
  );
 
  return new Response(JSON.stringify({ content: rankedContent }), {
    headers: { 'Content-Type': 'application/json' },
  });
});
 
function personalizeContent(items: any[], profile: any, recentEvents: any[], context: any): any[] {
  const preferences = profile?.preferences || {};
  const recentCategories = new Set(
    recentEvents
      .filter(e => e.event_name === 'content_engagement')
      .map(e => e.properties?.contentType)
  );
 
  return items
    .map(item => {
      let score = 0;
      score += (preferences[item.category] || 0.3) * 40;
      const ageHours = (Date.now() - new Date(item.created_at).getTime()) / 3600000;
      score += Math.max(0, 20 - ageHours * 0.5);
      if (recentCategories.has(item.category)) score -= 5;
      return { ...item, personalScore: score };
    })
    .sort((a, b) => b.personalScore - a.personalScore);
}

AI-Optimized Notification Timing

Push notification effectiveness depends as much on when you send as what you send. Here's how to predict the optimal notification time for each individual user.

Learning Activity Patterns

// notification-optimizer.ts
 
interface NotificationPlan {
  scheduledTime: Date;
  messageTemplate: string;
  priority: 'high' | 'medium' | 'low';
  channel: 'push' | 'in_app' | 'email';
}
 
class NotificationOptimizer {
  analyzeActivityPattern(events: any[]): number[] {
    const hourlyActivity = new Array(24).fill(0);
    for (const event of events) {
      const hour = new Date(event.created_at).getHours();
      hourlyActivity[hour] += 1;
    }
    const maxActivity = Math.max(...hourlyActivity, 1);
    return hourlyActivity.map(count => count / maxActivity);
  }
 
  findOptimalSendTime(
    activityPattern: number[],
    preferredWindow: { start: number; end: number } = { start: 8, end: 22 }
  ): number {
    let bestHour = 9;
    let bestScore = 0;
 
    for (let hour = preferredWindow.start; hour <= preferredWindow.end; hour++) {
      const h = hour % 24;
      // Target the hour just before peak activity
      const preActivityScore = activityPattern[(h + 1) % 24] || 0;
      const currentActivity = activityPattern[h] || 0;
      // Avoid sending when user is already in-app
      const score = preActivityScore * 0.7 + (1 - currentActivity) * 0.3;
 
      if (score > bestScore) {
        bestScore = score;
        bestHour = h;
      }
    }
 
    return bestHour;
  }
 
  async createNotificationPlan(
    userId: string,
    userProfile: UserProfile,
    events: any[]
  ): Promise<NotificationPlan> {
    const activityPattern = this.analyzeActivityPattern(events);
    const optimalHour = this.findOptimalSendTime(activityPattern);
    const template = this.selectTemplate(userProfile.segments);
 
    const now = new Date();
    const scheduledTime = new Date(now);
    scheduledTime.setHours(optimalHour, 0, 0, 0);
    if (scheduledTime <= now) {
      scheduledTime.setDate(scheduledTime.getDate() + 1);
    }
 
    return {
      scheduledTime,
      messageTemplate: template,
      priority: this.determinePriority(userProfile),
      channel: this.selectChannel(userProfile),
    };
  }
 
  private selectTemplate(segments: string[]): string {
    if (segments.includes('at_risk')) return 'miss_you';
    if (segments.includes('new_user')) return 'onboarding_tip';
    if (segments.includes('power_user')) return 'new_feature';
    return 'content_recommendation';
  }
 
  private determinePriority(profile: UserProfile): 'high' | 'medium' | 'low' {
    if (profile.segments.includes('at_risk')) return 'high';
    if (profile.segments.includes('new_user')) return 'medium';
    return 'low';
  }
 
  private selectChannel(profile: UserProfile): 'push' | 'in_app' | 'email' {
    if (profile.segments.includes('power_user')) return 'in_app';
    if (profile.segments.includes('at_risk')) return 'push';
    return 'push';
  }
}

Intelligent Frequency Control

Over-notifying drives users away. The system automatically adjusts sending frequency based on user response data.

// notification-frequency-controller.ts
 
class FrequencyController {
  calculateResponseRate(
    sentNotifications: any[],
    openedNotifications: any[]
  ): number {
    if (sentNotifications.length === 0) return 0.5;
    return openedNotifications.length / sentNotifications.length;
  }
 
  determineInterval(responseRate: number, segment: string): number {
    const baseInterval: Record<string, number> = {
      power_user: 24,     // Once daily
      activated: 48,       // Every 2 days
      new_user: 72,        // Every 3 days
      at_risk: 168,        // Weekly
      dormant: 336,        // Bi-weekly
    };
 
    const base = baseInterval[segment] || 72;
 
    if (responseRate > 0.3) {
      return Math.max(base * 0.5, 12);  // Min 12 hours
    } else if (responseRate < 0.05) {
      return Math.min(base * 1.5, 672);  // Max 4 weeks
    }
 
    return base;
  }
}

Performance Optimization and Fallback Strategies

A personalization engine must never slow down app rendering. Here's how to maintain performance while delivering personalized experiences.

Multi-Layer Caching

// cache-strategy.ts
 
class PersonalizationCache {
  private memoryCache: Map<string, { data: any; expiry: number }> = new Map();
 
  // 3-tier cache: Memory → AsyncStorage → Server
  async get(key: string): Promise<any | null> {
    // Layer 1: Memory (instant)
    const mem = this.memoryCache.get(key);
    if (mem && mem.expiry > Date.now()) return mem.data;
 
    // Layer 2: AsyncStorage (disk)
    try {
      const stored = await AsyncStorage.getItem(`pz:${key}`);
      if (stored) {
        const parsed = JSON.parse(stored);
        if (parsed.expiry > Date.now()) {
          this.memoryCache.set(key, parsed);
          return parsed.data;
        }
      }
    } catch {}
 
    // Layer 3: Server fetch (handled by caller)
    return null;
  }
 
  async set(key: string, data: any, ttlMs: number = 300000): Promise<void> {
    const entry = { data, expiry: Date.now() + ttlMs };
    this.memoryCache.set(key, entry);
    try {
      await AsyncStorage.setItem(`pz:${key}`, JSON.stringify(entry));
    } catch {
      await this.evictOldEntries();
    }
  }
 
  private async evictOldEntries(): Promise<void> {
    const allKeys = await AsyncStorage.getAllKeys();
    const pzKeys = allKeys.filter(k => k.startsWith('pz:'));
    const toRemove = pzKeys.slice(0, Math.floor(pzKeys.length / 2));
    await AsyncStorage.multiRemove(toRemove);
  }
}

Graceful Degradation

When AI APIs or the database are unreachable, the app must continue functioning normally with progressively simpler personalization.

// fallback-strategy.ts
 
class FallbackStrategy {
  async getPersonalizedContent(userId: string): Promise<any> {
    // Level 1: Full AI + real-time personalization
    try {
      return await this.fullPersonalization(userId);
    } catch (e) {
      console.warn('Full personalization failed:', e);
    }
 
    // Level 2: Cached profile-based personalization
    try {
      return await this.cachedPersonalization(userId);
    } catch (e) {
      console.warn('Cached personalization failed:', e);
    }
 
    // Level 3: Popularity-based (no personalization)
    return this.popularityBased();
  }
 
  private async fullPersonalization(userId: string) {
    const engine = PersonalizationEngine.getInstance();
    return engine.decide(userId);
  }
 
  private async cachedPersonalization(userId: string) {
    const cache = new PersonalizationCache();
    const profile = await cache.get(`profile:${userId}`);
    if (\!profile) throw new Error('No cached profile');
 
    return {
      uiLayout: 'default',
      contentOrder: this.simpleRank(profile.preferences),
      highlightedFeatures: profile.engagementPattern?.favoriteFeatures || [],
      notificationSchedule: { nextSendTime: '', messageTemplate: '' },
    };
  }
 
  private popularityBased() {
    return {
      uiLayout: 'default',
      contentOrder: ['hero_banner', 'trending_items', 'quick_actions', 'discovery_feed'],
      highlightedFeatures: [],
      notificationSchedule: { nextSendTime: '', messageTemplate: '' },
    };
  }
 
  private simpleRank(preferences: Record<string, number>): string[] {
    const sorted = Object.entries(preferences)
      .sort(([, a], [, b]) => b - a)
      .map(([category]) => `${category}_feed`);
    return ['hero_banner', ...sorted, 'quick_actions'];
  }
}

Measuring Effectiveness and Iterating

Accurate measurement is essential for continuous improvement. Here's how to set up the metrics framework.

Defining Key KPIs

Track these metrics to evaluate personalization impact.

Engagement metrics: average session duration (target: +20%), screens per session (target: +15%), content consumption rate (percentage of displayed content that was actually tapped or viewed).

Retention metrics: Day 1 / Day 7 / Day 30 retention rates, comparing personalized vs. non-personalized cohorts.

Revenue metrics: conversion rate (free → paid), ARPU (average revenue per user), LTV (customer lifetime value).

// metrics-collector.ts
 
class PersonalizationMetrics {
  async collectAndReport(userId: string, supabase: any): Promise<void> {
    const now = new Date();
    const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
 
    const { data: sessions } = await supabase
      .from('user_events')
      .select('session_id, created_at')
      .eq('user_id', userId)
      .gte('created_at', thirtyDaysAgo.toISOString())
      .order('created_at');
 
    const sessionDurations = this.calculateSessionDurations(sessions || []);
 
    const { data: profile } = await supabase
      .from('user_profiles')
      .select('created_at')
      .eq('user_id', userId)
      .single();
 
    const personalizationStartDate = profile?.created_at
      ? new Date(profile.created_at) : now;
 
    const before = sessionDurations.filter(s => s.date < personalizationStartDate);
    const after = sessionDurations.filter(s => s.date >= personalizationStartDate);
 
    const avgBefore = before.length > 0
      ? before.reduce((sum, s) => sum + s.duration, 0) / before.length : 0;
    const avgAfter = after.length > 0
      ? after.reduce((sum, s) => sum + s.duration, 0) / after.length : 0;
 
    const improvement = avgBefore > 0
      ? ((avgAfter - avgBefore) / avgBefore) * 100 : 0;
 
    await supabase.from('personalization_metrics').insert({
      user_id: userId,
      metric_type: 'session_duration',
      value_before: avgBefore,
      value_after: avgAfter,
      improvement_pct: improvement,
      measured_at: now.toISOString(),
    });
  }
 
  private calculateSessionDurations(events: any[]) {
    const sessions: Map<string, { start: number; end: number }> = new Map();
    for (const event of events) {
      const ts = new Date(event.created_at).getTime();
      const existing = sessions.get(event.session_id);
      if (existing) {
        existing.end = Math.max(existing.end, ts);
      } else {
        sessions.set(event.session_id, { start: ts, end: ts });
      }
    }
    return Array.from(sessions.values()).map(s => ({
      date: new Date(s.start),
      duration: (s.end - s.start) / 1000 / 60,
    }));
  }
}

What the docs won't tell you — lessons from production

Everything above is the design. But once I ran personalization inside my own apps, several things didn't go the way the sample code suggested. As an indie developer, I've run iOS and Android apps for years — mostly quiet, everyday utilities in the wallpaper, calming-tone, and intention space. Across those apps I've added and removed home-screen reordering and notification-timing optimization more times than I can count, and here are the operational details the documentation never mentions.

1. Personalizing on day one actually pushes new users away

This was my first mistake. In one wallpaper app I tried to apply the learned profile from the very first launch. With only two or three events on record, a skewed reordering kicked in and Day 1 retention dropped from 42% to 34%. The culprit is the cold-start problem: while behavioral signals are thin, the inference is just noise.

My current rule is to keep the default layout fixed for the first three sessions and only enable personalization gradually once there are enough signals. After reverting to this, Day 1 climbed back to 44%.

// cold-start-guard.ts — hold off on personalization until signals accumulate
 
const MIN_SESSIONS_FOR_PERSONALIZATION = 3;
const MIN_EVENTS_FOR_PERSONALIZATION = 20;
 
function shouldPersonalize(profile: UserProfile, eventCount: number): boolean {
  const sessions = profile.engagementPattern.peakHours.length; // rough session-count proxy
  if (profile.segments.includes('new_user')) {
    if (eventCount < MIN_EVENTS_FOR_PERSONALIZATION) return false;
    if (sessions < MIN_SESSIONS_FOR_PERSONALIZATION) return false;
  }
  return true;
}
 
// caller: if false, return the fixed default layout
const decision = shouldPersonalize(profile, eventCount)
  ? await engine.decide(userId)
  : getDefaultDecision();

2. Calling the AI on every session quietly inflates your bill

Behavioral analysis with the Claude API is powerful, but running it on every launch makes the cost stack up. I let this slip and only later noticed one month's API spend had ballooned to nearly four times normal — from around ¥9,000 to ¥38,000.

The fix is simple: run AI analysis on an event threshold or a once-a-day batch, not in real time. Do the UI reordering every time with lightweight rule-based scoring, and reserve the heavy AI inference for profile updates. Costs returned to baseline and the perceived accuracy barely changed.

// ai-analysis-throttle.ts — thin out how often the AI runs
 
const ANALYSIS_COOLDOWN_MS = 24 * 60 * 60 * 1000; // 24 hours
const EVENTS_TRIGGER_THRESHOLD = 80;               // re-analyze after 80 new events
 
function shouldRunAIAnalysis(
  lastAnalyzedAt: string | null,
  newEventCount: number
): boolean {
  if (newEventCount >= EVENTS_TRIGGER_THRESHOLD) return true; // follow sudden shifts immediately
  if (!lastAnalyzedAt) return true;
  const age = Date.now() - new Date(lastAnalyzedAt).getTime();
  return age >= ANALYSIS_COOLDOWN_MS; // otherwise once per day at most
}

3. Moving the layout itself earns you one-star reviews

This one is easy to overlook. Changing the order of content is welcome, but changing the skeleton — button positions, tab structure — makes users feel the app "got worse" or that "a button disappeared." During a period when I dynamically switched the home structure of an intention app, in-app inquiries rose to twelve a month.

My call: keep the layout skeleton fixed and confine personalization to the ordering and contents of cards and sections. After fixing the skeleton, inquiries fell to two a month. What you may change dynamically is the arrangement, not the position.

4. "Median of recent open times" beat "just before active"

The findOptimalSendTime in the body aims for the moment just before a user becomes active. But when I A/B tested it, sending at the median of the hours a user actually opened the app over the last two weeks produced consistently higher open rates in my apps. The theoretical "just before active" window misfires for users with irregular routines. After switching in a calming-tone app, notification open rate rose from 4.8% to 9.1%.

// median-open-hour.ts — target the median hour the user actually opened
 
function medianOpenHour(openEvents: { created_at: string }[]): number {
  if (openEvents.length === 0) return 9; // no data: 9am
  const hours = openEvents
    .map(e => new Date(e.created_at).getHours())
    .sort((a, b) => a - b);
  const mid = Math.floor(hours.length / 2);
  // for even counts, lean to the earlier hour (arriving a bit early is safer)
  return hours.length % 2 === 0 ? hours[mid - 1] : hours[mid];
}

5. Instant cache display feels great — until the order shuffles underneath

Showing a local cache first and fetching the latest in the background, like usePersonalization does, helps perceived speed. But applying the freshly fetched order immediately means cards swap while the user is mid-scroll, which reads as a visual jump. In a wallpaper grid I literally got "it makes me dizzy" complaints over this.

I now defer the newly fetched order rather than applying it on the spot — holding it until the next launch or until the user leaves the screen. It's stale-while-revalidate, but I've found that not applying the revalidate result instantly is what matters for the experience.

6. You can still personalize on-device for users who decline ATT

When you can't get App Tracking Transparency consent on iOS, it's tempting to give up on advanced server-side analysis. In my apps the decline rate hovered around 62%. But even without sending behavioral data to a server — aggregating only on-device and scoring locally — content reordering and notification timing still work perfectly well.

Not degrading the experience based on tracking consent is, to me, partly a matter of honesty toward people who'll use the app for a long time. Send only aggregated data for consenting users, keep everything on-device for those who decline — that two-tier setup lets privacy and experience coexist.

One next step

If you're about to add personalization, my advice is not to build every layer at once. What I learned the long way is that the quiet operational habit — change only the ordering, only after enough data has accumulated — beats flashy AI inference.

As a step you can take today, instrument event tracking only, then watch the data for a week. Once you can see when people actually open the app and which content holds them, what to optimize next becomes obvious on its own. AI analysis and dynamic layouts can wait until you have that feel.

If this saves a fellow solo developer from the cold-start and API-cost detours I took, I'll be glad. Thank you for reading.

Thank You for Reading

Rork Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.

✦Copy-paste ready implementation code
✦New advanced guides published daily
✦$5/mo or $10 for lifetime access

View Membership →