diff --git a/src/app/appStyles.ts b/src/app/appStyles.ts
index 817c867..7ca1c7a 100644
--- a/src/app/appStyles.ts
+++ b/src/app/appStyles.ts
@@ -197,4 +197,16 @@ export const appStyles = StyleSheet.create({
     top: 3,
     right: 4,
   },
+  refreshingIndicator: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'center',
+    paddingVertical: 12,
+    backgroundColor: '#f5f5f5',
+    gap: 8,
+  },
+  refreshingText: {
+    fontSize: 12,
+    color: '#666',
+  },
 });
diff --git a/src/app/tabs/ProjectList.tsx b/src/app/tabs/ProjectList.tsx
index b653cd2..52e34b7 100644
--- a/src/app/tabs/ProjectList.tsx
+++ b/src/app/tabs/ProjectList.tsx
@@ -9,12 +9,13 @@ import {
 import { logger } from '../../utils/logger';
 import { Project } from '../../types/db/types';
 import { getProjects } from '../../db/queries';
+import { appStyles as styles } from '../appStyles';
 import { useNavigation } from '@react-navigation/native';
+import { SyncButton } from '../../components/ui/SyncButton';
 import FluentLogo from '../../assets/icons/fluent-logo.svg';
-import { RootStackParamList } from '../../types/navigation/types';
 import { StackNavigationProp } from '@react-navigation/stack';
 import { Ionicons } from '@react-native-vector-icons/ionicons';
-import { appStyles as styles } from '../appStyles';
+import { RootStackParamList } from '../../types/navigation/types';
 
 const log = logger.create('ProjectListScreen');
 type Nav = StackNavigationProp<RootStackParamList, 'Projects'>;
@@ -23,6 +24,7 @@ export default function ProjectsScreen() {
   const navigation = useNavigation<Nav>();
   const [projects, setProjects] = useState<Project[]>([]);
   const [loading, setLoading] = useState(true);
+  const [refreshing, setRefreshing] = useState(false);
 
   useEffect(() => {
     loadProjects();
@@ -39,6 +41,16 @@ export default function ProjectsScreen() {
     }
   };
 
+  const handleSyncComplete = async () => {
+    log.info('Sync completed, refreshing projects list...');
+    setRefreshing(true);
+    try {
+      await loadProjects();
+    } finally {
+      setRefreshing(false);
+    }
+  };
+
   if (loading) {
     return (
       <View style={[styles.container, styles.centered]}>
@@ -53,6 +65,8 @@ export default function ProjectsScreen() {
         <FluentLogo width={160} height={54} />
       </View>
 
+      <SyncButton onSyncComplete={handleSyncComplete} />
+
       <View style={styles.sectionHeader}>
         <Ionicons name="folder-outline" size={24} color="#000" />
         <Text style={styles.sectionHeaderText}>Projects</Text>
@@ -62,6 +76,8 @@ export default function ProjectsScreen() {
         data={projects}
         keyExtractor={item => item.id.toString()}
         contentContainerStyle={styles.listContent}
+        refreshing={refreshing}
+        onRefresh={handleSyncComplete}
         renderItem={({ item }) => (
           <TouchableOpacity
             style={styles.cardRow}
diff --git a/src/components/ui/SyncButton.tsx b/src/components/ui/SyncButton.tsx
new file mode 100644
index 0000000..bdfee46
--- /dev/null
+++ b/src/components/ui/SyncButton.tsx
@@ -0,0 +1,217 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import {
+  TouchableOpacity,
+  Text,
+  StyleSheet,
+  ActivityIndicator,
+  View,
+  StyleProp,
+  ViewStyle,
+} from 'react-native';
+import { Ionicons } from '@react-native-vector-icons/ionicons';
+import { syncAllData } from '../../services/sync';
+import {
+  getSyncState,
+  getSyncError,
+  KV_KEYS,
+  getUserEmailSync,
+} from '../../services/storage';
+import { logger } from '../../utils/logger';
+
+const log = logger.create('SyncButton');
+
+type SyncStateType = 'normal' | 'syncing' | 'never' | 'error';
+
+interface SyncButtonProps {
+  onSyncComplete?: () => void;
+  style?: StyleProp<ViewStyle>;
+  onSyncStart?: () => void;
+}
+
+export function SyncButton({
+  onSyncComplete,
+  style,
+  onSyncStart,
+}: SyncButtonProps) {
+  const [stateType, setStateType] = useState<SyncStateType>('normal');
+  const [displayText, setDisplayText] = useState('');
+  const [isSyncing, setIsSyncing] = useState(false);
+
+  const getRelativeTime = (isoTimestamp: string | undefined): string => {
+    if (!isoTimestamp) return 'Never synced';
+
+    const now = new Date();
+    const syncTime = new Date(isoTimestamp);
+    const diffMs = now.getTime() - syncTime.getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+
+    if (diffMins < 1) return 'Just now';
+    if (diffMins < 60) return `${diffMins} min${diffMins > 1 ? 's' : ''} ago`;
+    if (diffHours < 24)
+      return `${diffHours} hour${diffHours > 1 ? 's' : ''} ago`;
+    return `${diffDays} day${diffDays > 1 ? 's' : ''} ago`;
+  };
+
+  const getFailedStep = (): string | null => {
+    const projectsError = getSyncError(KV_KEYS.SYNC_ERROR_PROJECTS);
+    if (projectsError) return 'projects';
+
+    const chaptersError = getSyncError(KV_KEYS.SYNC_ERROR_CHAPTER_ASSIGNMENTS);
+    if (chaptersError) return 'chapter assignments';
+
+    const projectUnitsError = getSyncError(KV_KEYS.SYNC_ERROR_PROJECT_UNITS);
+    if (projectUnitsError) return 'project units';
+
+    const bibleTextsError = getSyncError(KV_KEYS.SYNC_ERROR_BIBLE_TEXTS);
+    if (bibleTextsError) return 'bible texts';
+
+    return null;
+  };
+
+  const updateState = useCallback(() => {
+    if (isSyncing) {
+      setStateType('syncing');
+      setDisplayText('Syncing...');
+    } else {
+      const failedStep = getFailedStep();
+      const syncState = getSyncState();
+
+      if (failedStep) {
+        setStateType('error');
+        setDisplayText(`Sync failed: ${failedStep}`);
+      } else if (!syncState.lastSyncedAt) {
+        setStateType('never');
+        setDisplayText('Never synced');
+      } else {
+        setStateType('normal');
+        setDisplayText(
+          `Last synced: ${getRelativeTime(syncState.lastSyncedAt)}`,
+        );
+      }
+    }
+  }, [isSyncing]);
+
+  useEffect(() => {
+    updateState();
+  }, [isSyncing, updateState]);
+
+  useEffect(() => {
+    if (stateType === 'normal') {
+      const interval = setInterval(() => {
+        updateState();
+      }, 60000);
+
+      return () => clearInterval(interval);
+    }
+  }, [stateType, updateState]);
+
+  const handleSync = useCallback(async () => {
+    try {
+      setIsSyncing(true);
+      onSyncStart?.();
+      const email = getUserEmailSync();
+
+      if (!email) {
+        log.error('No user email found for sync');
+        setIsSyncing(false);
+        return;
+      }
+
+      log.info('Triggering sync...');
+      await syncAllData(email);
+
+      log.info('Sync completed successfully');
+      updateState();
+      onSyncComplete?.();
+    } catch (error) {
+      log.error('Sync failed', { error });
+      updateState();
+    } finally {
+      setIsSyncing(false);
+    }
+  }, [onSyncStart, onSyncComplete, updateState]);
+
+  const getStateColors = () => {
+    switch (stateType) {
+      case 'syncing':
+        return {
+          backgroundColor: '#e6f1fb',
+          borderColor: '#b5d4f4',
+          textColor: '#1a6ef5',
+        };
+      case 'error':
+        return {
+          backgroundColor: '#fcebeb',
+          borderColor: '#f7c1c1',
+          textColor: '#d32f2f',
+        };
+      case 'never':
+      case 'normal':
+      default:
+        return {
+          backgroundColor: '#fff',
+          borderColor: '#e0e0e0',
+          textColor: '#999',
+        };
+    }
+  };
+
+  const colors = getStateColors();
+
+  return (
+    <View
+      style={[
+        styles.container,
+        style,
+        {
+          backgroundColor: colors.backgroundColor,
+          borderColor: colors.borderColor,
+        },
+      ]}
+    >
+      <View style={styles.content}>
+        <Text style={[styles.text, { color: colors.textColor }]}>
+          {displayText}
+        </Text>
+      </View>
+
+      <TouchableOpacity
+        onPress={handleSync}
+        disabled={isSyncing}
+        activeOpacity={0.7}
+        style={styles.syncButton}
+      >
+        {isSyncing ? (
+          <ActivityIndicator size="small" color={colors.textColor} />
+        ) : (
+          <Ionicons name="refresh" size={20} color={colors.textColor} />
+        )}
+      </TouchableOpacity>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    paddingHorizontal: 16,
+    paddingVertical: 12,
+    borderBottomWidth: 1,
+    marginBottom: 8,
+  },
+  content: {
+    flex: 1,
+  },
+  text: {
+    fontSize: 14,
+    fontWeight: '500',
+  },
+  syncButton: {
+    padding: 8,
+    marginLeft: 12,
+  },
+});
diff --git a/src/db/queries.ts b/src/db/queries.ts
index 6d982e5..47629ab 100644
--- a/src/db/queries.ts
+++ b/src/db/queries.ts
@@ -85,7 +85,7 @@ export async function getChapterAssignmentById(
       bibleId: row.bible_id,
       bookId: row.book_id,
       chapterNumber: row.chapter_number,
-      assignedUserId: row.assigned_user_id ?? undefined,
+      assignedUserId: row.assigned_user_id,
       status: row.status,
       submittedTime: row.submitted_time ?? undefined,
       updatedAt: row.updated_at,
diff --git a/src/services/storage.ts b/src/services/storage.ts
new file mode 100644
index 0000000..47a476c
--- /dev/null
+++ b/src/services/storage.ts
@@ -0,0 +1,103 @@
+import { Storage } from '@op-engineering/op-sqlite';
+import { logger } from '../utils/logger';
+
+const log = logger.create('KVStorage');
+
+export const kvStorage = new Storage({
+  location: 'kv',
+});
+
+export const KV_KEYS = {
+  USER_ID: 'userId',
+  USER_EMAIL: 'userEmail',
+
+  LAST_SYNCED_AT: 'last_synced_at',
+  SYNC_COUNT_PROJECTS: 'sync_count_projects',
+  SYNC_COUNT_CHAPTERS: 'sync_count_chapters',
+  SYNC_COUNT_BIBLES: 'sync_count_bibles',
+  SYNC_ERROR_PROJECTS: 'sync_error_projects',
+  SYNC_ERROR_CHAPTER_ASSIGNMENTS: 'sync_error_chapter_assignments',
+  SYNC_ERROR_PROJECT_UNITS: 'sync_error_project_units',
+  SYNC_ERROR_BIBLE_TEXTS: 'sync_error_bible_texts',
+} as const;
+
+export function getUserIdSync(): string {
+  return kvStorage.getItemSync(KV_KEYS.USER_ID) ?? '';
+}
+
+export function getUserEmailSync(): string {
+  return kvStorage.getItemSync(KV_KEYS.USER_EMAIL) ?? '';
+}
+
+export function setUserSync(userId: string, userEmail: string) {
+  kvStorage.setItemSync(KV_KEYS.USER_ID, userId);
+  kvStorage.setItemSync(KV_KEYS.USER_EMAIL, userEmail);
+  log.info('User stored in KV', { userId, userEmail });
+}
+
+export function getLastSyncedAt(): string {
+  return kvStorage.getItemSync(KV_KEYS.LAST_SYNCED_AT) ?? '';
+}
+
+export function setLastSyncedAt(timestamp: string) {
+  kvStorage.setItemSync(KV_KEYS.LAST_SYNCED_AT, timestamp);
+  log.info('Last synced timestamp updated', { timestamp });
+}
+
+export function getSyncCount(
+  key: (typeof KV_KEYS)[keyof typeof KV_KEYS],
+): number {
+  const value = kvStorage.getItemSync(key);
+  return value ? parseInt(value, 10) : 0;
+}
+
+export function setSyncCount(
+  key: (typeof KV_KEYS)[keyof typeof KV_KEYS],
+  count: number,
+) {
+  kvStorage.setItemSync(key, String(count));
+  log.info('Sync count updated', { key, count });
+}
+
+export function setSyncError(
+  key: (typeof KV_KEYS)[keyof typeof KV_KEYS],
+  errorMessage: string,
+) {
+  kvStorage.setItemSync(key, errorMessage);
+  log.info('Sync error stored', { key, errorMessage });
+}
+
+export function getSyncError(
+  key: (typeof KV_KEYS)[keyof typeof KV_KEYS],
+): string | undefined {
+  return kvStorage.getItemSync(key);
+}
+
+export function clearSyncError(key: (typeof KV_KEYS)[keyof typeof KV_KEYS]) {
+  kvStorage.removeItemSync(key);
+  log.info('Sync error cleared', { key });
+}
+
+export function clearAllSyncErrors() {
+  clearSyncError(KV_KEYS.SYNC_ERROR_PROJECTS);
+  clearSyncError(KV_KEYS.SYNC_ERROR_CHAPTER_ASSIGNMENTS);
+  clearSyncError(KV_KEYS.SYNC_ERROR_PROJECT_UNITS);
+  clearSyncError(KV_KEYS.SYNC_ERROR_BIBLE_TEXTS);
+  log.info('All sync errors cleared');
+}
+
+export type SyncState = {
+  lastSyncedAt: string;
+  projectsCount: number;
+  chaptersCount: number;
+  biblesCount: number;
+};
+
+export function getSyncState(): SyncState {
+  return {
+    lastSyncedAt: getLastSyncedAt(),
+    projectsCount: getSyncCount(KV_KEYS.SYNC_COUNT_PROJECTS),
+    chaptersCount: getSyncCount(KV_KEYS.SYNC_COUNT_CHAPTERS),
+    biblesCount: getSyncCount(KV_KEYS.SYNC_COUNT_BIBLES),
+  };
+}
diff --git a/src/services/sync.ts b/src/services/sync.ts
index ac22bb5..807ca2c 100644
--- a/src/services/sync.ts
+++ b/src/services/sync.ts
@@ -11,9 +11,18 @@ import {
   getChaptersToSync,
 } from '../db/repository';
 import { logger } from '../utils/logger';
+import { getDatabase } from '../db/db';
 import { ApiBook, ApiVerse } from '../types/api/types';
+import {
+  setUserSync,
+  setSyncCount,
+  setLastSyncedAt,
+  KV_KEYS,
+  setSyncError,
+} from '../services/storage';
 
 const log = logger.create('SyncService');
+const db = getDatabase();
 
 export async function syncUser(email: string) {
   try {
@@ -27,6 +36,7 @@ export async function syncUser(email: string) {
 
     await insertUser(user);
 
+    setUserSync(String(user.id), user.email);
     log.info('User synced', { email: user.email });
 
     return user;
@@ -63,10 +73,15 @@ export async function syncProjects(userId: number, email: string) {
     const projects = await FluentAPI.getUserProjects(userId, email);
 
     await insertProjects(projects);
+    const result = await db.execute('SELECT COUNT(*) as count FROM projects');
+    const totalProjectsCount = result.rows?.[0]?.count || 0;
+    setSyncCount(KV_KEYS.SYNC_COUNT_PROJECTS, Number(totalProjectsCount));
 
     log.info('Projects synced', { count: projects.length });
   } catch (error) {
-    log.error('Project sync failed', { error });
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log.error('Project sync failed', { error: errorMessage });
+    setSyncError(KV_KEYS.SYNC_ERROR_PROJECTS, errorMessage);
   }
 }
 
@@ -85,14 +100,22 @@ export async function syncChapterAssignments(userId: number, email: string) {
       await insertProjectUnits(allAssignments);
 
       await insertChapterAssignments(allAssignments);
-      log.info('Chapter assignments synced', { count: allAssignments.length });
+
+      const result = await db.execute(
+        'SELECT COUNT(*) as count FROM chapter_assignments',
+      );
+      const totalChaptersCount = result.rows?.[0]?.count || 0;
+      setSyncCount(KV_KEYS.SYNC_COUNT_CHAPTERS, Number(totalChaptersCount));
+
+      log.info('Chapter assignments synced', {
+        apiCount: allAssignments.length,
+        totalInDb: totalChaptersCount,
+      });
     }
   } catch (error) {
-    log.error('Chapter assignment sync failed', {
-      message: error instanceof Error ? error.message : String(error),
-      stack: error instanceof Error ? error.stack : undefined,
-      raw: error,
-    });
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log.error('Chapter assignment sync failed', { error: errorMessage });
+    setSyncError(KV_KEYS.SYNC_ERROR_CHAPTER_ASSIGNMENTS, errorMessage);
   }
 }
 
@@ -104,7 +127,8 @@ export async function syncBibleTexts(email: string) {
 
     if (bibleGroups.size === 0) {
       log.info('No chapters to sync');
-      return;
+      setSyncCount(KV_KEYS.SYNC_COUNT_BIBLES, 0);
+      return 0;
     }
 
     let totalTextsInserted = 0;
@@ -143,33 +167,55 @@ export async function syncBibleTexts(email: string) {
           });
         }
       } catch (error) {
-        log.error(`Failed to sync texts for bible ${bibleId}:`, { error });
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        log.error(`Failed to sync texts for bible ${bibleId}:`, {
+          error: errorMessage,
+        });
+        setSyncError(KV_KEYS.SYNC_ERROR_BIBLE_TEXTS, errorMessage);
         continue;
       }
     }
-
-    log.info('Bible texts sync completed', { count: totalTextsInserted });
+    const result = await db.execute(
+      'SELECT COUNT(DISTINCT bible_id) as count FROM bible_texts',
+    );
+    const uniqueBiblesCount = result.rows?.[0]?.count || 0;
+    setSyncCount(KV_KEYS.SYNC_COUNT_BIBLES, Number(uniqueBiblesCount));
+
+    log.info('Bible texts sync completed', {
+      textsInserted: totalTextsInserted,
+      uniqueBiblesInDb: uniqueBiblesCount,
+    });
   } catch (error) {
-    log.error('Bible texts sync failed', { error });
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log.error('Bible texts sync failed', { error: errorMessage });
+    setSyncError(KV_KEYS.SYNC_ERROR_BIBLE_TEXTS, errorMessage);
   }
 }
 
 export async function syncAllData(email: string) {
   log.info('Starting full sync...');
 
-  const user = await syncUser(email);
+  try {
+    const user = await syncUser(email);
 
-  await syncMasterData();
+    await syncMasterData();
 
-  await syncProjects(user.id, email);
+    await syncProjects(user.id, email);
 
-  await syncChapterAssignments(user.id, email);
+    await syncChapterAssignments(user.id, email);
 
-  try {
-    await syncBibleTexts(email);
-  } catch (e) {
-    log.warn('Bible text sync failed, continuing...', { error: e });
-  }
+    try {
+      await syncBibleTexts(email);
+    } catch (e) {
+      log.warn('Bible text sync failed, continuing...', { error: e });
+    }
+    const now = new Date().toISOString();
+    setLastSyncedAt(now);
 
-  log.info('Full sync completed successfully!');
+    log.info('Full sync completed successfully!', { timestamp: now });
+  } catch (error) {
+    log.error('Full sync failed', { error });
+    throw error;
+  }
 }
diff --git a/src/types/db/types.ts b/src/types/db/types.ts
index a56c51b..d62472e 100644
--- a/src/types/db/types.ts
+++ b/src/types/db/types.ts
@@ -57,7 +57,7 @@ export interface ChapterAssignmentData {
   bibleId: number;
   bookId: number;
   chapterNumber: number;
-  assignedUserId?: number | null;
+  assignedUserId?: number;
   status: string;
   submittedTime?: string | null;
   updatedAt?: string;
@@ -72,7 +72,7 @@ export interface ChapterAssignmentRow {
   bible_id: number;
   book_id: number;
   chapter_number: number;
-  assigned_user_id?: number | null;
+  assigned_user_id?: number;
   status: string;
   submitted_time?: string | null;
   updated_at?: string;
@@ -86,7 +86,7 @@ export interface ChapterListItem {
   chapter_number: number;
   status: string;
   book_name: string;
-  assigned_user_id?: number | null;
+  assigned_user_id?: number;
 }
 
 export interface ChapterRow {