diff --git a/backend/services/trialService.ts b/backend/services/trialService.ts
new file mode 100644
index 00000000..885bed7e
--- /dev/null
+++ b/backend/services/trialService.ts
@@ -0,0 +1,192 @@
+import {
+  TrialConfig,
+  ABTestAssignment,
+  ConversionFunnelEvent,
+  TrialReminderSchedule,
+  TrialStatus,
+  TrialDuration,
+  TrialFeatureAccess,
+  PaymentRequirement,
+} from '../../src/types/trial';
+
+interface BackendTrialConfig {
+  id: string;
+  subscriptionId: string;
+  duration: TrialDuration;
+  featureAccess: TrialFeatureAccess;
+  paymentRequirement: PaymentRequirement;
+  abTestId?: string;
+  status: TrialStatus;
+  startDate?: string;
+  endDate?: string;
+  convertedAt?: string;
+  reminderScheduleId?: string;
+  metadata?: Record<string, any>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface BackendABTestAssignment {
+  id: string;
+  abTestId: string;
+  userId: string;
+  variantName: string;
+  assignedAt: string;
+  cohort?: string;
+}
+
+interface BackendConversionFunnelEvent {
+  id: string;
+  trialConfigId: string;
+  eventType: ConversionFunnelEvent['eventType'];
+  userId: string;
+  variantName?: string;
+  timestamp: string;
+  metadata?: Record<string, any>;
+}
+
+export class BackendTrialService {
+  private trialConfigs: Map<string, BackendTrialConfig> = new Map();
+  private assignments: Map<string, BackendABTestAssignment> = new Map();
+  private funnelEvents: Map<string, BackendConversionFunnelEvent> = new Map();
+
+  createTrialConfig(
+    subscriptionId: string,
+    duration: TrialDuration,
+    featureAccess: TrialFeatureAccess,
+    paymentRequirement: PaymentRequirement,
+    abTestId?: string
+  ): BackendTrialConfig {
+    const now = new Date().toISOString();
+    const endDate = new Date();
+    switch (duration) {
+      case TrialDuration.SEVEN_DAYS:
+        endDate.setDate(endDate.getDate() + 7);
+        break;
+      case TrialDuration.FOURTEEN_DAYS:
+        endDate.setDate(endDate.getDate() + 14);
+        break;
+      case TrialDuration.TWENTY_ONE_DAYS:
+        endDate.setDate(endDate.getDate() + 21);
+        break;
+      case TrialDuration.THIRTY_DAYS:
+        endDate.setDate(endDate.getDate() + 30);
+        break;
+    }
+
+    const config: BackendTrialConfig = {
+      id: `${subscriptionId}-${Date.now()}`,
+      subscriptionId,
+      duration,
+      featureAccess,
+      paymentRequirement,
+      abTestId,
+      status: TrialStatus.ACTIVE,
+      startDate: now,
+      endDate: endDate.toISOString(),
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    this.trialConfigs.set(config.id, config);
+    return config;
+  }
+
+  validateTrialConfig(config: Partial<BackendTrialConfig>): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (!config.subscriptionId) {
+      errors.push('Subscription ID is required');
+    }
+    if (!config.duration) {
+      errors.push('Trial duration is required');
+    }
+    if (!config.featureAccess) {
+      errors.push('Feature access is required');
+    }
+    if (!config.paymentRequirement) {
+      errors.push('Payment requirement is required');
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  assignABTest(abTestId: string, userId: string, variantName: string, cohort?: string): BackendABTestAssignment {
+    const assignment: BackendABTestAssignment = {
+      id: `${abTestId}-${userId}-${Date.now()}`,
+      abTestId,
+      userId,
+      variantName,
+      assignedAt: new Date().toISOString(),
+      cohort,
+    };
+
+    this.assignments.set(assignment.id, assignment);
+    return assignment;
+  }
+
+  processFunnelEvent(event: Omit<BackendConversionFunnelEvent, 'id' | 'timestamp'>): BackendConversionFunnelEvent {
+    const funnelEvent: BackendConversionFunnelEvent = {
+      ...event,
+      id: `evt-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`,
+      timestamp: new Date().toISOString(),
+    };
+
+    this.funnelEvents.set(funnelEvent.id, funnelEvent);
+    return funnelEvent;
+  }
+
+  getTrialConfig(id: string): BackendTrialConfig | undefined {
+    return this.trialConfigs.get(id);
+  }
+
+  getTrialConfigBySubscription(subscriptionId: string): BackendTrialConfig | undefined {
+    for (const config of this.trialConfigs.values()) {
+      if (config.subscriptionId === subscriptionId) {
+        return config;
+      }
+    }
+    return undefined;
+  }
+
+  getAssignmentsForTest(abTestId: string): BackendABTestAssignment[] {
+    return Array.from(this.assignments.values()).filter((a) => a.abTestId === abTestId);
+  }
+
+  getFunnelEvents(trialConfigId: string): BackendConversionFunnelEvent[] {
+    return Array.from(this.funnelEvents.values()).filter((e) => e.trialConfigId === trialConfigId);
+  }
+
+  getConversionStats(abTestId?: string): { totalTrials: number; convertedTrials: number; conversionRate: number } {
+    const configs = abTestId
+      ? Array.from(this.trialConfigs.values()).filter((c) => c.abTestId === abTestId)
+      : Array.from(this.trialConfigs.values());
+
+    const totalTrials = configs.length;
+    const convertedTrials = configs.filter((c) => c.status === TrialStatus.CONVERTED).length;
+    const conversionRate = totalTrials > 0 ? convertedTrials / totalTrials : 0;
+
+    return { totalTrials, convertedTrials, conversionRate };
+  }
+
+  convertTrial(trialId: string): BackendTrialConfig | undefined {
+    const config = this.trialConfigs.get(trialId);
+    if (!config) return undefined;
+
+    config.status = TrialStatus.CONVERTED;
+    config.convertedAt = new Date().toISOString();
+    config.updatedAt = new Date().toISOString();
+    return config;
+  }
+
+  expireTrial(trialId: string): BackendTrialConfig | undefined {
+    const config = this.trialConfigs.get(trialId);
+    if (!config) return undefined;
+
+    config.status = TrialStatus.EXPIRED;
+    config.updatedAt = new Date().toISOString();
+    return config;
+  }
+}
+
+export const backendTrialService = new BackendTrialService();
diff --git a/src/navigation/AppNavigator.tsx b/src/navigation/AppNavigator.tsx
index 0f32b2ee..27e5f95b 100644
--- a/src/navigation/AppNavigator.tsx
+++ b/src/navigation/AppNavigator.tsx
@@ -77,6 +77,7 @@ const PaymentMethodsScreen = lazyScreen(() =>
   }))
 );
 const AnalyticsDashboard = lazyScreen(() => import('../../app/screens/AnalyticsDashboard'));
+const TrialDetailsScreen = lazyScreen(() => import('../screens/TrialDetailsScreen'));
 
 const Tab = createBottomTabNavigator<TabParamList>();
 const Stack = createNativeStackNavigator<RootStackParamList>();
@@ -199,6 +200,11 @@ const HomeStack = () => (
       component={IntegrationGuidesScreen}
       options={{ headerShown: false }}
     />
+    <Stack.Screen
+      name="TrialDetails"
+      component={TrialDetailsScreen}
+      options={{ title: 'Trial Details', headerShown: true }}
+    />
   </Stack.Navigator>
 );
 
diff --git a/src/navigation/types.ts b/src/navigation/types.ts
index 10bf40b0..410a86c3 100644
--- a/src/navigation/types.ts
+++ b/src/navigation/types.ts
@@ -48,6 +48,7 @@ export type RootStackParamList = {
   ChangePlan: { subscriptionId: string };
   PaymentMethods: undefined;
   AnalyticsDashboard: undefined;
+  TrialDetails: undefined;
   NotFound: { reason?: string };
 };
 
diff --git a/src/screens/TrialDetailsScreen.tsx b/src/screens/TrialDetailsScreen.tsx
new file mode 100644
index 00000000..5b81efe0
--- /dev/null
+++ b/src/screens/TrialDetailsScreen.tsx
@@ -0,0 +1,752 @@
+import React, { useState, useEffect } from 'react';
+import {
+  View,
+  Text,
+  StyleSheet,
+  ScrollView,
+  TouchableOpacity,
+  TextInput,
+} from 'react-native';
+import { useNavigation, useRoute, RouteProp } from '@react-navigation/native';
+import { NativeStackNavigationProp } from '@react-navigation/native-stack';
+import { RootStackParamList } from '../navigation/types';
+import { useThemeColors } from '../hooks/useThemeColors';
+import { useTrialStore } from '../store';
+import { trialConfigService, abTestService, conversionTracker, reminderScheduler } from '../services/trialService';
+import { TrialStatus, TrialDuration, TrialFeatureAccess, PaymentRequirement, TrialReminder } from '../types/trial';
+import { FormScreen } from '../components/common/ScreenTemplates';
+import { Card } from '../components/common/Card';
+import { Button } from '../components/common/Button';
+import { spacing, typography, borderRadius } from '../utils/constants';
+
+type TrialDetailsRouteProp = RouteProp<RootStackParamList, 'TrialDetails'>;
+
+interface ConversionFunnelData {
+  eventType: string;
+  count: number;
+  percentage: number;
+}
+
+export const TrialDetailsScreen: React.FC = () => {
+  const navigation = useNavigation<NativeStackNavigationProp<RootStackParamList>>();
+  const route = useRoute<TrialDetailsRouteProp>();
+  const colors = useThemeColors();
+  const styles = React.useMemo(() => createStyles(colors), [colors]);
+  const { trialConfigs, abTestAssignments, conversionFunnel, isLoading, error } = useTrialStore();
+
+  const [selectedTrial, setSelectedTrial] = useState<string | null>(null);
+  const [showCreateForm, setShowCreateForm] = useState(false);
+  const [newTrialConfig, setNewTrialConfig] = useState({
+    subscriptionId: '',
+    duration: TrialDuration.SEVEN_DAYS,
+    featureAccess: TrialFeatureAccess.FULL,
+    paymentRequirement: PaymentRequirement.REQUIRED,
+    abTestId: '',
+  });
+
+  useEffect(() => {
+    if (route.params?.trialId) {
+      setSelectedTrial(route.params.trialId);
+    }
+  }, [route.params]);
+
+  const selectedTrialConfig = selectedTrial
+    ? trialConfigs.find((tc) => tc.id === selectedTrial)
+    : null;
+
+  const getFunnelSteps = (trialId: string): ConversionFunnelData[] => {
+    const events = conversionTracker.getFunnelForTrial(trialId);
+    const steps: Record<string, number> = {};
+    events.forEach((e) => {
+      steps[e.eventType] = (steps[e.eventType] || 0) + 1;
+    });
+    const total = events.length || 1;
+    return Object.entries(steps).map(([eventType, count]) => ({
+      eventType,
+      count,
+      percentage: (count / total) * 100,
+    }));
+  };
+
+  const handleCreateTrial = async () => {
+    try {
+      await trialConfigService.create(
+        newTrialConfig.subscriptionId,
+        newTrialConfig.duration,
+        newTrialConfig.featureAccess,
+        newTrialConfig.paymentRequirement,
+        newTrialConfig.abTestId || undefined
+      );
+      setShowCreateForm(false);
+      setNewTrialConfig({
+        subscriptionId: '',
+        duration: TrialDuration.SEVEN_DAYS,
+        featureAccess: TrialFeatureAccess.FULL,
+        paymentRequirement: PaymentRequirement.REQUIRED,
+        abTestId: '',
+      });
+    } catch {
+      // Error handled by service
+    }
+  };
+
+  const handleConvertTrial = async (trialId: string) => {
+    await useTrialStore.getState().convertTrial(trialId);
+    await conversionTracker.track({
+      trialConfigId: trialId,
+      eventType: 'trial_converted',
+      userId: 'current-user',
+    });
+  };
+
+  const handleExpireTrial = async (trialId: string) => {
+    await useTrialStore.getState().expireTrial(trialId);
+    await conversionTracker.track({
+      trialConfigId: trialId,
+      eventType: 'trial_expired',
+      userId: 'current-user',
+    });
+  };
+
+  const renderStatusBadge = (status: TrialStatus) => {
+    let backgroundColor = colors.border.default;
+    let textColor = colors.text;
+
+    switch (status) {
+      case TrialStatus.ACTIVE:
+        backgroundColor = colors.primary;
+        textColor = colors.background;
+        break;
+      case TrialStatus.CONVERTED:
+        backgroundColor = colors.success;
+        textColor = colors.background;
+        break;
+      case TrialStatus.EXPIRED:
+        backgroundColor = colors.warning;
+        textColor = colors.background;
+        break;
+      case TrialStatus.CANCELLED:
+        backgroundColor = colors.error;
+        textColor = colors.background;
+        break;
+    }
+
+    return (
+      <View style={[styles.statusBadge, { backgroundColor }]}>
+        <Text style={[styles.statusText, { color: textColor }]}>{status.toUpperCase()}</Text>
+      </View>
+    );
+  };
+
+  const renderTrialCard = (trial: any) => (
+    <TouchableOpacity
+      key={trial.id}
+      onPress={() => setSelectedTrial(trial.id)}
+      style={styles.trialCard}
+    >
+      <View style={styles.trialCardHeader}>
+        <Text style={styles.trialCardTitle}>Trial {trial.id.substring(0, 8)}</Text>
+        {renderStatusBadge(trial.status)}
+      </View>
+      <View style={styles.trialCardMeta}>
+        <Text style={styles.trialCardMetaText}>
+          Duration: {TrialDuration[trial.duration] || trial.duration}
+        </Text>
+        <Text style={styles.trialCardMetaText}>
+          Access: {TrialFeatureAccess[trial.featureAccess] || trial.featureAccess}
+        </Text>
+      </View>
+      {trial.abTestId && (
+        <View style={styles.abTestTag}>
+          <Text style={styles.abTestText}>A/B Test: {trial.abTestId}</Text>
+        </View>
+      )}
+    </TouchableOpacity>
+  );
+
+  const renderFunnelChart = (steps: ConversionFunnelData[]) => {
+    if (steps.length === 0) {
+      return <Text style={styles.emptyText}>No funnel data available</Text>;
+    }
+
+    const maxCount = Math.max(...steps.map((s) => s.count));
+
+    return (
+      <View style={styles.funnelContainer}>
+        {steps.map((step, index) => (
+          <View key={step.eventType} style={styles.funnelStep}>
+            <View style={styles.funnelStepHeader}>
+              <Text style={styles.funnelStepLabel}>{step.eventType.replace(/_/g, ' ')}</Text>
+              <Text style={styles.funnelStepCount}>{step.count}</Text>
+            </View>
+            <View style={styles.funnelBarContainer}>
+              <View
+                style={[
+                  styles.funnelBar,
+                  {
+                    width: `${(step.count / maxCount) * 100}%`,
+                    backgroundColor: colors.primary,
+                  },
+                ]}
+              />
+            </View>
+            <Text style={styles.funnelPercentage}>{step.percentage.toFixed(1)}%</Text>
+          </View>
+        ))}
+      </View>
+    );
+  };
+
+  const renderVariantStats = () => {
+    const abTestId = selectedTrialConfig?.abTestId;
+    if (!abTestId) {
+      return <Text style={styles.emptyText}>No active A/B test for this trial</Text>;
+    }
+
+    const assignments = abTestService.getAssignmentsForTest(abTestId);
+    const distribution = abTestService.getVariantDistribution(abTestId);
+    const stats = useTrialStore.getState().getConversionStats(abTestId);
+
+    return (
+      <View style={styles.variantStatsContainer}>
+        <Text style={styles.sectionTitle}>A/B Test Results</Text>
+        <View style={styles.statsRow}>
+          <Card padding="medium" style={styles.statCard}>
+            <Text style={styles.statValue}>{stats.totalTrials}</Text>
+            <Text style={styles.statLabel}>Total Trials</Text>
+          </Card>
+          <Card padding="medium" style={styles.statCard}>
+            <Text style={styles.statValue}>{(stats.conversionRate * 100).toFixed(1)}%</Text>
+            <Text style={styles.statLabel}>Conversion Rate</Text>
+          </Card>
+        </View>
+        <Text style={styles.subsectionTitle}>Variant Distribution</Text>
+        {Object.entries(distribution).map(([variant, count]) => (
+          <View key={variant} style={styles.distributionRow}>
+            <Text style={styles.variantName}>{variant}</Text>
+            <View style={styles.distributionBarContainer}>
+              <View
+                style={[
+                  styles.distributionBar,
+                  { width: `${(count / stats.totalTrials) * 100}%`, backgroundColor: colors.secondary },
+                ]}
+              />
+            </View>
+            <Text style={styles.distributionCount}>{count}</Text>
+          </View>
+        ))}
+      </View>
+    );
+  };
+
+  const renderReminders = () => {
+    const schedule = selectedTrialConfig
+      ? reminderScheduler.getByTrialConfigId(selectedTrial.id)
+      : undefined;
+
+    if (!schedule) {
+      return (
+        <Card padding="medium">
+          <Text style={styles.emptyText}>No reminders scheduled</Text>
+        </Card>
+      );
+    }
+
+    return (
+      <Card padding="medium">
+        <Text style={styles.sectionTitle}>Reminder Schedule</Text>
+        {schedule.reminders.map((reminder: TrialReminder) => (
+          <View key={reminder.id} style={styles.reminderRow}>
+            <Text style={styles.reminderType}>{reminder.type}</Text>
+            <Text style={styles.reminderStatus}>{reminder.sent ? 'Sent' : 'Pending'}</Text>
+            {reminder.message && <Text style={styles.reminderMessage}>{reminder.message}</Text>}
+          </View>
+        ))}
+      </Card>
+    );
+  };
+
+  return (
+    <FormScreen
+      title="Free Trial Details"
+      subtitle="Manage trial configurations and A/B tests"
+      testID="trial-details-screen"
+    >
+      <ScrollView style={styles.scrollContent}>
+        {error && <Text style={styles.errorText}>{error}</Text>}
+
+        {/* Trial Configs List */}
+        <Card padding="medium" style={styles.section}>
+          <View style={styles.sectionHeader}>
+            <Text style={styles.sectionTitle}>Trial Configurations</Text>
+            <Button
+              title="New"
+              onPress={() => setShowCreateForm(!showCreateForm)}
+              variant="secondary"
+              size="small"
+            />
+          </View>
+          {trialConfigs.length === 0 ? (
+            <Text style={styles.emptyText}>No trial configurations yet</Text>
+          ) : (
+            trialConfigs.map(renderTrialCard)
+          )}
+        </Card>
+
+        {/* Create Trial Form */}
+        {showCreateForm && (
+          <Card padding="medium" style={styles.section}>
+            <Text style={styles.sectionTitle}>Create Trial Config</Text>
+            <View style={styles.formGroup}>
+              <Text style={styles.label}>Subscription ID</Text>
+              <TextInput
+                style={styles.input}
+                value={newTrialConfig.subscriptionId}
+                onChangeText={(text) =>
+                  setNewTrialConfig((prev) => ({ ...prev, subscriptionId: text }))
+                }
+                placeholder="Enter subscription ID"
+                placeholderTextColor={colors.textSecondary}
+              />
+            </View>
+
+            <View style={styles.formGroup}>
+              <Text style={styles.label}>Duration</Text>
+              <View style={styles.pickerContainer}>
+                {Object.values(TrialDuration).map((duration) => (
+                  <TouchableOpacity
+                    key={duration}
+                    style={[
+                      styles.pickerOption,
+                      newTrialConfig.duration === duration && styles.pickerOptionSelected,
+                    ]}
+                    onPress={() =>
+                      setNewTrialConfig((prev) => ({ ...prev, duration }))
+                    }
+                  >
+                    <Text
+                      style={[
+                        styles.pickerText,
+                        newTrialConfig.duration === duration && styles.pickerTextSelected,
+                      ]}
+                    >
+                      {duration.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase())}
+                    </Text>
+                  </TouchableOpacity>
+                ))}
+              </View>
+            </View>
+
+            <View style={styles.formGroup}>
+              <Text style={styles.label}>Feature Access</Text>
+              <View style={styles.pickerContainer}>
+                {Object.values(TrialFeatureAccess).map((access) => (
+                  <TouchableOpacity
+                    key={access}
+                    style={[
+                      styles.pickerOption,
+                      newTrialConfig.featureAccess === access && styles.pickerOptionSelected,
+                    ]}
+                    onPress={() =>
+                      setNewTrialConfig((prev) => ({ ...prev, featureAccess: access }))
+                    }
+                  >
+                    <Text
+                      style={[
+                        styles.pickerText,
+                        newTrialConfig.featureAccess === access && styles.pickerTextSelected,
+                      ]}
+                    >
+                      {access.charAt(0).toUpperCase() + access.slice(1)}
+                    </Text>
+                  </TouchableOpacity>
+                ))}
+              </View>
+            </View>
+
+            <View style={styles.formGroup}>
+              <Text style={styles.label}>Payment Requirement</Text>
+              <View style={styles.pickerContainer}>
+                {Object.values(PaymentRequirement).map((req) => (
+                  <TouchableOpacity
+                    key={req}
+                    style={[
+                      styles.pickerOption,
+                      newTrialConfig.paymentRequirement === req && styles.pickerOptionSelected,
+                    ]}
+                    onPress={() =>
+                      setNewTrialConfig((prev) => ({ ...prev, paymentRequirement: req }))
+                    }
+                  >
+                    <Text
+                      style={[
+                        styles.pickerText,
+                        newTrialConfig.paymentRequirement === req && styles.pickerTextSelected,
+                      ]}
+                    >
+                      {req.charAt(0).toUpperCase() + req.slice(1)}
+                    </Text>
+                  </TouchableOpacity>
+                ))}
+              </View>
+            </View>
+
+            <Button
+              title="Create Trial"
+              onPress={handleCreateTrial}
+              fullWidth
+              loading={isLoading}
+            />
+          </Card>
+        )}
+
+        {/* Selected Trial Details */}
+        {selectedTrialConfig && (
+          <>
+            <Card padding="medium" style={styles.section}>
+              <Text style={styles.sectionTitle}>Trial Details</Text>
+              <View style={styles.detailRow}>
+                <Text style={styles.detailLabel}>Status</Text>
+                {renderStatusBadge(selectedTrialConfig.status)}
+              </View>
+              <View style={styles.detailRow}>
+                <Text style={styles.detailLabel}>Duration</Text>
+                <Text style={styles.detailValue}>{TrialDuration[selectedTrialConfig.duration]}</Text>
+              </View>
+              <View style={styles.detailRow}>
+                <Text style={styles.detailLabel}>Feature Access</Text>
+                <Text style={styles.detailValue}>
+                  {TrialFeatureAccess[selectedTrialConfig.featureAccess]}
+                </Text>
+              </View>
+              <View style={styles.detailRow}>
+                <Text style={styles.detailLabel}>Payment</Text>
+                <Text style={styles.detailValue}>
+                  {PaymentRequirement[selectedTrialConfig.paymentRequirement]}
+                </Text>
+              </View>
+              {selectedTrialConfig.startDate && (
+                <View style={styles.detailRow}>
+                  <Text style={styles.detailLabel}>Started</Text>
+                  <Text style={styles.detailValue}>
+                    {new Date(selectedTrialConfig.startDate).toLocaleDateString()}
+                  </Text>
+                </View>
+              )}
+              {selectedTrialConfig.endDate && (
+                <View style={styles.detailRow}>
+                  <Text style={styles.detailLabel}>Ends</Text>
+                  <Text style={styles.detailValue}>
+                    {new Date(selectedTrialConfig.endDate).toLocaleDateString()}
+                  </Text>
+                </View>
+              )}
+
+              <View style={styles.actionButtons}>
+                {selectedTrialConfig.status === TrialStatus.ACTIVE && (
+                  <>
+                    <Button
+                      title="Convert Trial"
+                      onPress={() => handleConvertTrial(selectedTrialConfig.id)}
+                      variant="primary"
+                      size="medium"
+                      style={styles.actionButton}
+                    />
+                    <Button
+                      title="Expire Trial"
+                      onPress={() => handleExpireTrial(selectedTrialConfig.id)}
+                      variant="danger"
+                      size="medium"
+                      style={styles.actionButton}
+                    />
+                  </>
+                )}
+              </View>
+            </Card>
+
+            {/* Reminders */}
+            {renderReminders()}
+
+            {/* Conversion Funnel */}
+            <Card padding="medium" style={styles.section}>
+              <Text style={styles.sectionTitle}>Conversion Funnel</Text>
+              {renderFunnelChart(getFunnelSteps(selectedTrialConfig.id))}
+            </Card>
+
+            {/* A/B Test Stats */}
+            {renderVariantStats()}
+          </>
+        )}
+      </ScrollView>
+    </FormScreen>
+  );
+};
+
+function createStyles(colors: ReturnType<typeof useThemeColors>) {
+  return StyleSheet.create({
+    scrollContent: {
+      flex: 1,
+    },
+    section: {
+      marginBottom: spacing.lg,
+    },
+    errorText: {
+      color: colors.error || '#ef4444',
+      marginBottom: spacing.md,
+      ...typography.body,
+    },
+    sectionHeader: {
+      flexDirection: 'row',
+      justifyContent: 'space-between',
+      alignItems: 'center',
+      marginBottom: spacing.md,
+    },
+    sectionTitle: {
+      ...typography.h3,
+      color: colors.text,
+      marginBottom: spacing.md,
+    },
+    subsectionTitle: {
+      ...typography.body,
+      color: colors.textSecondary || '#cbd5e1',
+      marginTop: spacing.md,
+      marginBottom: spacing.sm,
+      fontWeight: '600',
+    },
+    trialCard: {
+      padding: spacing.md,
+      marginBottom: spacing.sm,
+      borderRadius: borderRadius.md,
+      borderWidth: 1,
+      borderColor: colors.border?.default || '#334155',
+      backgroundColor: colors.surface || '#1e293b',
+    },
+    trialCardHeader: {
+      flexDirection: 'row',
+      justifyContent: 'space-between',
+      alignItems: 'center',
+      marginBottom: spacing.xs,
+    },
+    trialCardTitle: {
+      ...typography.body,
+      color: colors.text,
+      fontWeight: '600',
+    },
+    trialCardMeta: {
+      flexDirection: 'row',
+      gap: spacing.md,
+    },
+    trialCardMetaText: {
+      ...typography.caption,
+      color: colors.textSecondary || '#cbd5e1',
+    },
+    abTestTag: {
+      marginTop: spacing.xs,
+      paddingHorizontal: spacing.sm,
+      paddingVertical: spacing.xs / 2,
+      borderRadius: borderRadius.sm,
+      backgroundColor: colors.accent || '#06b6d4',
+      alignSelf: 'flex-start',
+    },
+    abTestText: {
+      ...typography.caption,
+      color: colors.background || '#0f172a',
+      fontWeight: '600',
+    },
+    statusBadge: {
+      paddingHorizontal: spacing.sm,
+      paddingVertical: spacing.xs / 2,
+      borderRadius: borderRadius.sm,
+    },
+    statusText: {
+      ...typography.caption,
+      fontWeight: '600',
+    },
+    formGroup: {
+      marginBottom: spacing.md,
+    },
+    label: {
+      ...typography.body,
+      color: colors.text,
+      marginBottom: spacing.xs,
+      fontWeight: '500',
+    },
+    input: {
+      ...typography.body,
+      backgroundColor: colors.surface || '#1e293b',
+      padding: spacing.md,
+      borderRadius: borderRadius.md,
+      borderWidth: 1,
+      borderColor: colors.border?.default || '#334155',
+      color: colors.text,
+    },
+    pickerContainer: {
+      flexDirection: 'row',
+      flexWrap: 'wrap',
+      gap: spacing.sm,
+    },
+    pickerOption: {
+      paddingHorizontal: spacing.md,
+      paddingVertical: spacing.sm,
+      borderRadius: borderRadius.md,
+      backgroundColor: colors.surface || '#1e293b',
+      borderWidth: 1,
+      borderColor: colors.border?.default || '#334155',
+    },
+    pickerOptionSelected: {
+      backgroundColor: colors.brand?.primary || '#6366f1',
+      borderColor: colors.brand?.primary || '#6366f1',
+    },
+    pickerText: {
+      ...typography.caption,
+      color: colors.text,
+    },
+    pickerTextSelected: {
+      color: colors.onPrimary || '#ffffff',
+      fontWeight: '600',
+    },
+    detailRow: {
+      flexDirection: 'row',
+      justifyContent: 'space-between',
+      alignItems: 'center',
+      paddingVertical: spacing.sm,
+      borderBottomWidth: 1,
+      borderBottomColor: colors.border?.default || '#334155',
+    },
+    detailLabel: {
+      ...typography.body,
+      color: colors.textSecondary || '#cbd5e1',
+    },
+    detailValue: {
+      ...typography.body,
+      color: colors.text,
+      fontWeight: '500',
+      textTransform: 'capitalize',
+    },
+    actionButtons: {
+      flexDirection: 'row',
+      gap: spacing.sm,
+      marginTop: spacing.lg,
+    },
+    actionButton: {
+      flex: 1,
+    },
+    emptyText: {
+      ...typography.body,
+      color: colors.textSecondary || '#cbd5e1',
+      textAlign: 'center',
+      paddingVertical: spacing.lg,
+    },
+    funnelContainer: {
+      gap: spacing.md,
+    },
+    funnelStep: {
+      marginBottom: spacing.sm,
+    },
+    funnelStepHeader: {
+      flexDirection: 'row',
+      justifyContent: 'space-between',
+      alignItems: 'center',
+      marginBottom: spacing.xs,
+    },
+    funnelStepLabel: {
+      ...typography.body,
+      color: colors.text,
+      fontWeight: '500',
+      textTransform: 'capitalize',
+    },
+    funnelStepCount: {
+      ...typography.body,
+      color: colors.text,
+      fontWeight: '600',
+    },
+    funnelBarContainer: {
+      height: 12,
+      borderRadius: borderRadius.sm,
+      backgroundColor: colors.border?.default || '#334155',
+      overflow: 'hidden',
+    },
+    funnelBar: {
+      height: '100%',
+      borderRadius: borderRadius.sm,
+    },
+    funnelPercentage: {
+      ...typography.caption,
+      color: colors.textSecondary || '#cbd5e1',
+      marginTop: spacing.xs,
+    },
+    variantStatsContainer: {
+      marginTop: spacing.md,
+    },
+    statsRow: {
+      flexDirection: 'row',
+      gap: spacing.sm,
+      marginBottom: spacing.md,
+    },
+    statCard: {
+      flex: 1,
+      alignItems: 'center',
+    },
+    statValue: {
+      ...typography.h2,
+      color: colors.text,
+      fontWeight: '700',
+    },
+    statLabel: {
+      ...typography.caption,
+      color: colors.textSecondary || '#cbd5e1',
+      textAlign: 'center',
+    },
+    distributionRow: {
+      flexDirection: 'row',
+      alignItems: 'center',
+      marginBottom: spacing.sm,
+      gap: spacing.sm,
+    },
+    variantName: {
+      ...typography.caption,
+      color: colors.text,
+      width: 80,
+      fontWeight: '500',
+    },
+    distributionBarContainer: {
+      flex: 1,
+      height: 8,
+      borderRadius: borderRadius.sm,
+      backgroundColor: colors.border?.default || '#334155',
+      overflow: 'hidden',
+    },
+    distributionBar: {
+      height: '100%',
+      borderRadius: borderRadius.sm,
+    },
+    distributionCount: {
+      ...typography.caption,
+      color: colors.text,
+      width: 30,
+      textAlign: 'right',
+    },
+    reminderRow: {
+      paddingVertical: spacing.sm,
+      borderBottomWidth: 1,
+      borderBottomColor: colors.border?.default || '#334155',
+    },
+    reminderType: {
+      ...typography.body,
+      color: colors.text,
+      fontWeight: '600',
+    },
+    reminderStatus: {
+      ...typography.caption,
+      color: colors.textSecondary || '#cbd5e1',
+      marginLeft: spacing.sm,
+    },
+    reminderMessage: {
+      ...typography.caption,
+      color: colors.textSecondary || '#cbd5e1',
+      marginTop: spacing.xs,
+    },
+  });
+}
+
+export default TrialDetailsScreen;
diff --git a/src/services/trialService.ts b/src/services/trialService.ts
new file mode 100644
index 00000000..374a93f1
--- /dev/null
+++ b/src/services/trialService.ts
@@ -0,0 +1,337 @@
+import {
+  TrialConfig,
+  TrialDuration,
+  TrialFeatureAccess,
+  PaymentRequirement,
+  TrialStatus,
+  ABTestAssignment,
+  ConversionFunnelEvent,
+  TrialReminderSchedule,
+  TrialReminder,
+} from '../types/trial';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+const TRIAL_CONFIGS_KEY = 'subtrackr-trial-configs';
+const AB_TEST_ASSIGNMENTS_KEY = 'subtrackr-ab-test-assignments';
+const FUNNEL_EVENTS_KEY = 'subtrackr-funnel-events';
+const REMINDER_SCHEDULES_KEY = 'subtrackr-reminder-schedules';
+
+class TrialConfigService {
+  private configs: TrialConfig[] = [];
+
+  async load(): Promise<void> {
+    try {
+      const stored = await AsyncStorage.getItem(TRIAL_CONFIGS_KEY);
+      if (stored) {
+        this.configs = JSON.parse(stored);
+      }
+    } catch {
+      this.configs = [];
+    }
+  }
+
+  async save(): Promise<void> {
+    try {
+      await AsyncStorage.setItem(TRIAL_CONFIGS_KEY, JSON.stringify(this.configs));
+    } catch {
+      // ignore
+    }
+  }
+
+  create(
+    subscriptionId: string,
+    duration: TrialDuration,
+    featureAccess: TrialFeatureAccess,
+    paymentRequirement: PaymentRequirement,
+    abTestId?: string
+  ): TrialConfig {
+    const now = new Date();
+    const endDate = new Date(now);
+    switch (duration) {
+      case TrialDuration.SEVEN_DAYS:
+        endDate.setDate(endDate.getDate() + 7);
+        break;
+      case TrialDuration.FOURTEEN_DAYS:
+        endDate.setDate(endDate.getDate() + 14);
+        break;
+      case TrialDuration.TWENTY_ONE_DAYS:
+        endDate.setDate(endDate.getDate() + 21);
+        break;
+      case TrialDuration.THIRTY_DAYS:
+        endDate.setDate(endDate.getDate() + 30);
+        break;
+    }
+
+    const config: TrialConfig = {
+      id: `${subscriptionId}-${Date.now()}`,
+      subscriptionId,
+      duration,
+      featureAccess,
+      paymentRequirement,
+      abTestId,
+      status: TrialStatus.ACTIVE,
+      startDate: now,
+      endDate,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    this.configs.push(config);
+    this.save();
+    return config;
+  }
+
+  update(id: string, updates: Partial<TrialConfig>): TrialConfig | null {
+    const index = this.configs.findIndex((c) => c.id === id);
+    if (index === -1) return null;
+
+    this.configs[index] = {
+      ...this.configs[index],
+      ...updates,
+      updatedAt: new Date(),
+    };
+    this.save();
+    return this.configs[index];
+  }
+
+  validate(config: Partial<TrialConfig>): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (!config.subscriptionId) {
+      errors.push('Subscription ID is required');
+    }
+
+    if (!config.duration) {
+      errors.push('Trial duration is required');
+    }
+
+    if (!config.featureAccess) {
+      errors.push('Feature access is required');
+    }
+
+    if (!config.paymentRequirement) {
+      errors.push('Payment requirement is required');
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  getBySubscriptionId(subscriptionId: string): TrialConfig | undefined {
+    return this.configs.find((c) => c.subscriptionId === subscriptionId);
+  }
+
+  getAll(): TrialConfig[] {
+    return [...this.configs];
+  }
+}
+
+class ABTestService {
+  private assignments: ABTestAssignment[] = [];
+
+  async load(): Promise<void> {
+    try {
+      const stored = await AsyncStorage.getItem(AB_TEST_ASSIGNMENTS_KEY);
+      if (stored) {
+        this.assignments = JSON.parse(stored);
+      }
+    } catch {
+      this.assignments = [];
+    }
+  }
+
+  async save(): Promise<void> {
+    try {
+      await AsyncStorage.setItem(AB_TEST_ASSIGNMENTS_KEY, JSON.stringify(this.assignments));
+    } catch {
+      // ignore
+    }
+  }
+
+  assignCohort(abTestId: string, userId: string, variantName: string, cohort?: string): ABTestAssignment {
+    const now = new Date();
+    const assignment: ABTestAssignment = {
+      id: `${abTestId}-${userId}-${Date.now()}`,
+      abTestId,
+      userId,
+      variantName,
+      assignedAt: now,
+      cohort,
+    };
+
+    this.assignments.push(assignment);
+    this.save();
+    return assignment;
+  }
+
+  getAssignmentsForTest(abTestId: string): ABTestAssignment[] {
+    return this.assignments.filter((a) => a.abTestId === abTestId);
+  }
+
+  getAssignmentsForUser(userId: string): ABTestAssignment[] {
+    return this.assignments.filter((a) => a.userId === userId);
+  }
+
+  getVariantDistribution(abTestId: string): Record<string, number> {
+    const testAssignments = this.getAssignmentsForTest(abTestId);
+    return testAssignments.reduce<Record<string, number>>((acc, a) => {
+      acc[a.variantName] = (acc[a.variantName] || 0) + 1;
+      return acc;
+    }, {});
+  }
+}
+
+class ConversionTracker {
+  private events: ConversionFunnelEvent[] = [];
+
+  async load(): Promise<void> {
+    try {
+      const stored = await AsyncStorage.getItem(FUNNEL_EVENTS_KEY);
+      if (stored) {
+        this.events = JSON.parse(stored);
+      }
+    } catch {
+      this.events = [];
+    }
+  }
+
+  async save(): Promise<void> {
+    try {
+      await AsyncStorage.setItem(FUNNEL_EVENTS_KEY, JSON.stringify(this.events));
+    } catch {
+      // ignore
+    }
+  }
+
+  track(event: Omit<ConversionFunnelEvent, 'id' | 'timestamp'>): ConversionFunnelEvent {
+    const funnelEvent: ConversionFunnelEvent = {
+      ...event,
+      id: `evt-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`,
+      timestamp: new Date(),
+    };
+
+    this.events.push(funnelEvent);
+    this.save();
+    return funnelEvent;
+  }
+
+  getFunnelForTrial(trialConfigId: string): ConversionFunnelEvent[] {
+    return this.events.filter((e) => e.trialConfigId === trialConfigId);
+  }
+
+  getFunnelForABTest(abTestId: string): ConversionFunnelEvent[] {
+    const trialConfigs = trialConfigService.getAll().filter((c) => c.abTestId === abTestId);
+    const trialIds = new Set(trialConfigs.map((c) => c.id));
+    return this.events.filter((e) => trialIds.has(e.trialConfigId));
+  }
+
+  getConversionRate(abTestId?: string): number {
+    const events = abTestId ? this.getFunnelForABTest(abTestId) : this.events;
+    const starts = events.filter((e) => e.eventType === 'trial_started').length;
+    const conversions = events.filter((e) => e.eventType === 'trial_converted').length;
+    return starts > 0 ? conversions / starts : 0;
+  }
+
+  getFunnelSteps(abTestId?: string): Record<string, number> {
+    const events = abTestId ? this.getFunnelForABTest(abTestId) : this.events;
+    return events.reduce<Record<string, number>>((acc, e) => {
+      acc[e.eventType] = (acc[e.eventType] || 0) + 1;
+      return acc;
+    }, {});
+  }
+}
+
+class ReminderScheduler {
+  private schedules: TrialReminderSchedule[] = [];
+
+  async load(): Promise<void> {
+    try {
+      const stored = await AsyncStorage.getItem(REMINDER_SCHEDULES_KEY);
+      if (stored) {
+        this.schedules = JSON.parse(stored);
+      }
+    } catch {
+      this.schedules = [];
+    }
+  }
+
+  async save(): Promise<void> {
+    try {
+      await AsyncStorage.setItem(REMINDER_SCHEDULES_KEY, JSON.stringify(this.schedules));
+    } catch {
+      // ignore
+    }
+  }
+
+  createSchedule(trialConfigId: string, userId: string): TrialReminderSchedule {
+    const now = new Date();
+    const reminders: TrialReminder[] = [
+      {
+        id: `rem-d3-${Date.now()}`,
+        type: 'D-3',
+        scheduledAt: new Date(now.getTime() + 3 * 24 * 60 * 60 * 1000),
+        sent: false,
+        message: 'Your trial ends in 3 days. Convert now to keep your subscription.',
+      },
+      {
+        id: `rem-d1-${Date.now()}`,
+        type: 'D-1',
+        scheduledAt: new Date(now.getTime() + 1 * 24 * 60 * 60 * 1000),
+        sent: false,
+        message: 'Your trial ends tomorrow. Convert now to avoid interruption.',
+      },
+      {
+        id: `rem-dd-${Date.now()}`,
+        type: 'D-DAY',
+        scheduledAt: new Date(now.getTime()),
+        sent: false,
+        message: 'Your trial ends today. Convert now to continue your subscription.',
+      },
+    ];
+
+    const schedule: TrialReminderSchedule = {
+      id: `sched-${trialConfigId}`,
+      trialConfigId,
+      userId,
+      reminders,
+      createdAt: now,
+    };
+
+    this.schedules.push(schedule);
+    this.save();
+    return schedule;
+  }
+
+  getByTrialConfigId(trialConfigId: string): TrialReminderSchedule | undefined {
+    return this.schedules.find((s) => s.trialConfigId === trialConfigId);
+  }
+
+  markSent(reminderId: string): void {
+    for (const schedule of this.schedules) {
+      const reminder = schedule.reminders.find((r) => r.id === reminderId);
+      if (reminder) {
+        reminder.sent = true;
+        reminder.sentAt = new Date();
+        break;
+      }
+    }
+    this.save();
+  }
+
+  getPendingReminders(): TrialReminder[] {
+    const now = new Date();
+    const pending: TrialReminder[] = [];
+    for (const schedule of this.schedules) {
+      for (const reminder of schedule.reminders) {
+        if (!reminder.sent && reminder.scheduledAt <= now) {
+          pending.push({ ...reminder, sentAt: reminder.sentAt });
+        }
+      }
+    }
+    return pending;
+  }
+}
+
+export const trialConfigService = new TrialConfigService();
+export const abTestService = new ABTestService();
+export const conversionTracker = new ConversionTracker();
+export const reminderScheduler = new ReminderScheduler();
diff --git a/src/store/index.ts b/src/store/index.ts
index 8d98cc10..b48a37fa 100644
--- a/src/store/index.ts
+++ b/src/store/index.ts
@@ -1,3 +1,4 @@
+export { useTrialStore } from './trialStore';
 export { useSubscriptionStore } from './subscriptionStore';
 export { useInvoiceStore } from './invoiceStore';
 export { useTransactionQueueStore } from './transactionQueueStore';
diff --git a/src/store/trialStore.ts b/src/store/trialStore.ts
new file mode 100644
index 00000000..becca52f
--- /dev/null
+++ b/src/store/trialStore.ts
@@ -0,0 +1,199 @@
+import { create } from 'zustand';
+import { persist, createJSONStorage } from 'zustand/middleware';
+import { debouncedAsyncStorageAdapter } from '../utils/storage';
+import {
+  TrialConfig,
+  ABTestAssignment,
+  ConversionFunnelEvent,
+  TrialReminderSchedule,
+  TrialReminder,
+  TrialStatus,
+  TrialDuration,
+} from '../types/trial';
+
+const STORAGE_KEY = 'subtrackr-trials';
+const STORE_VERSION = 1;
+
+interface TrialState {
+  trialConfigs: TrialConfig[];
+  abTestAssignments: ABTestAssignment[];
+  conversionFunnel: ConversionFunnelEvent[];
+  trialReminders: TrialReminderSchedule[];
+  isLoading: boolean;
+  error: string | null;
+
+  createTrialConfig: (config: Omit<TrialConfig, 'id' | 'createdAt' | 'updatedAt'>) => Promise<TrialConfig>;
+  updateTrialConfig: (id: string, updates: Partial<TrialConfig>) => Promise<void>;
+  assignABTest: (assignment: Omit<ABTestAssignment, 'id' | 'assignedAt'>) => Promise<ABTestAssignment>;
+  recordFunnelEvent: (event: Omit<ConversionFunnelEvent, 'id' | 'timestamp'>) => Promise<ConversionFunnelEvent>;
+  scheduleReminder: (schedule: Omit<TrialReminderSchedule, 'id' | 'createdAt'>) => Promise<TrialReminderSchedule>;
+  convertTrial: (trialId: string) => Promise<void>;
+  expireTrial: (trialId: string) => Promise<void>;
+  getConversionStats: (abTestId?: string) => {
+    totalTrials: number;
+    convertedTrials: number;
+    conversionRate: number;
+  };
+}
+
+const generateId = (): string => {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${timestamp}-${random}`;
+};
+
+export const useTrialStore = create<TrialState>()(
+  persist(
+    (set, get) => ({
+      trialConfigs: [],
+      abTestAssignments: [],
+      conversionFunnel: [],
+      trialReminders: [],
+      isLoading: false,
+      error: null,
+
+      createTrialConfig: async (config) => {
+        set({ isLoading: true, error: null });
+        try {
+          const now = new Date();
+          const trialConfig: TrialConfig = {
+            ...config,
+            id: generateId(),
+            createdAt: now,
+            updatedAt: now,
+          };
+          set((state) => ({
+            trialConfigs: [...state.trialConfigs, trialConfig],
+            isLoading: false,
+          }));
+          return trialConfig;
+        } catch (error) {
+          set({ error: 'Failed to create trial config', isLoading: false });
+          throw error;
+        }
+      },
+
+      updateTrialConfig: async (id, updates) => {
+        set({ isLoading: true, error: null });
+        try {
+          set((state) => ({
+            trialConfigs: state.trialConfigs.map((tc) =>
+              tc.id === id ? { ...tc, ...updates, updatedAt: new Date() } : tc
+            ),
+            isLoading: false,
+          }));
+        } catch (error) {
+          set({ error: 'Failed to update trial config', isLoading: false });
+          throw error;
+        }
+      },
+
+      assignABTest: async (assignment) => {
+        set({ isLoading: true, error: null });
+        try {
+          const abTestAssignment: ABTestAssignment = {
+            ...assignment,
+            id: generateId(),
+            assignedAt: new Date(),
+          };
+          set((state) => ({
+            abTestAssignments: [...state.abTestAssignments, abTestAssignment],
+            isLoading: false,
+          }));
+          return abTestAssignment;
+        } catch (error) {
+          set({ error: 'Failed to assign A/B test', isLoading: false });
+          throw error;
+        }
+      },
+
+      recordFunnelEvent: async (event) => {
+        set({ isLoading: true, error: null });
+        try {
+          const funnelEvent: ConversionFunnelEvent = {
+            ...event,
+            id: generateId(),
+            timestamp: new Date(),
+          };
+          set((state) => ({
+            conversionFunnel: [...state.conversionFunnel, funnelEvent],
+            isLoading: false,
+          }));
+          return funnelEvent;
+        } catch (error) {
+          set({ error: 'Failed to record funnel event', isLoading: false });
+          throw error;
+        }
+      },
+
+      scheduleReminder: async (schedule) => {
+        set({ isLoading: true, error: null });
+        try {
+          const reminderSchedule: TrialReminderSchedule = {
+            ...schedule,
+            id: generateId(),
+            createdAt: new Date(),
+          };
+          set((state) => ({
+            trialReminders: [...state.trialReminders, reminderSchedule],
+            isLoading: false,
+          }));
+          return reminderSchedule;
+        } catch (error) {
+          set({ error: 'Failed to schedule reminder', isLoading: false });
+          throw error;
+        }
+      },
+
+      convertTrial: async (trialId) => {
+        set({ isLoading: true, error: null });
+        try {
+          set((state) => ({
+            trialConfigs: state.trialConfigs.map((tc) =>
+              tc.id === trialId
+                ? { ...tc, status: TrialStatus.CONVERTED, convertedAt: new Date(), updatedAt: new Date() }
+                : tc
+            ),
+            isLoading: false,
+          }));
+        } catch (error) {
+          set({ error: 'Failed to convert trial', isLoading: false });
+          throw error;
+        }
+      },
+
+      expireTrial: async (trialId) => {
+        set({ isLoading: true, error: null });
+        try {
+          set((state) => ({
+            trialConfigs: state.trialConfigs.map((tc) =>
+              tc.id === trialId
+                ? { ...tc, status: TrialStatus.EXPIRED, updatedAt: new Date() }
+                : tc
+            ),
+            isLoading: false,
+          }));
+        } catch (error) {
+          set({ error: 'Failed to expire trial', isLoading: false });
+          throw error;
+        }
+      },
+
+      getConversionStats: (abTestId?: string) => {
+        const configs = get().trialConfigs;
+        const filtered = abTestId
+          ? configs.filter((tc) => tc.abTestId === abTestId)
+          : configs;
+        const totalTrials = filtered.length;
+        const convertedTrials = filtered.filter((tc) => tc.status === TrialStatus.CONVERTED).length;
+        const conversionRate = totalTrials > 0 ? convertedTrials / totalTrials : 0;
+        return { totalTrials, convertedTrials, conversionRate };
+      },
+    }),
+    {
+      name: STORAGE_KEY,
+      version: STORE_VERSION,
+      storage: createJSONStorage(() => debouncedAsyncStorageAdapter),
+    }
+  )
+);
diff --git a/src/types/trial.ts b/src/types/trial.ts
new file mode 100644
index 00000000..a2dc4300
--- /dev/null
+++ b/src/types/trial.ts
@@ -0,0 +1,98 @@
+export enum TrialDuration {
+  SEVEN_DAYS = 'seven_days',
+  FOURTEEN_DAYS = 'fourteen_days',
+  TWENTY_ONE_DAYS = 'twenty_one_days',
+  THIRTY_DAYS = 'thirty_days',
+}
+
+export enum TrialFeatureAccess {
+  FULL = 'full',
+  LIMITED = 'limited',
+}
+
+export enum PaymentRequirement {
+  REQUIRED = 'required',
+  OPTIONAL = 'optional',
+  DEFERRED = 'deferred',
+}
+
+export enum TrialStatus {
+  ACTIVE = 'active',
+  CONVERTED = 'converted',
+  EXPIRED = 'expired',
+  CANCELLED = 'cancelled',
+}
+
+export interface ABTestVariant {
+  name: string;
+  weight: number;
+  config: Record<string, any>;
+}
+
+export interface TrialConfig {
+  id: string;
+  subscriptionId: string;
+  duration: TrialDuration;
+  featureAccess: TrialFeatureAccess;
+  paymentRequirement: PaymentRequirement;
+  abTestId?: string;
+  status: TrialStatus;
+  startDate?: Date;
+  endDate?: Date;
+  convertedAt?: Date;
+  reminderScheduleId?: string;
+  metadata?: Record<string, any>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface ABTestAssignment {
+  id: string;
+  abTestId: string;
+  userId: string;
+  variantName: string;
+  assignedAt: Date;
+  cohort?: string;
+}
+
+export interface ConversionFunnelEvent {
+  id: string;
+  trialConfigId: string;
+  eventType: 'trial_started' | 'feature_accessed' | 'reminder_sent' | 'dashboard_visited' | 'payment_clicked' | 'payment_completed' | 'trial_expired' | 'trial_cancelled' | 'trial_converted';
+  userId: string;
+  variantName?: string;
+  timestamp: Date;
+  metadata?: Record<string, any>;
+}
+
+export interface TrialReminderSchedule {
+  id: string;
+  trialConfigId: string;
+  userId: string;
+  reminders: TrialReminder[];
+  createdAt: Date;
+}
+
+export interface TrialReminder {
+  id: string;
+  type: 'D-3' | 'D-1' | 'D-DAY';
+  scheduledAt: Date;
+  sent: boolean;
+  sentAt?: Date;
+  message?: string;
+}
+
+export interface TrialStats {
+  totalTrials: number;
+  activeTrials: number;
+  convertedTrials: number;
+  expiredTrials: number;
+  cancelledTrials: number;
+  conversionRate: number;
+  avgTimeToConvert: number;
+  variantStats: Record<string, {
+    trials: number;
+    conversions: number;
+    conversionRate: number;
+  }>;
+}