diff --git a/src/app/tabs/ProjectList.tsx b/src/app/tabs/ProjectList.tsx
index 52e34b7..1467292 100644
--- a/src/app/tabs/ProjectList.tsx
+++ b/src/app/tabs/ProjectList.tsx
@@ -17,10 +17,10 @@ import { StackNavigationProp } from '@react-navigation/stack';
 import { Ionicons } from '@react-native-vector-icons/ionicons';
 import { RootStackParamList } from '../../types/navigation/types';
 
-const log = logger.create('ProjectListScreen');
+const log = logger.create('ProjectList');
 type Nav = StackNavigationProp<RootStackParamList, 'Projects'>;
 
-export default function ProjectsScreen() {
+export default function ProjectList() {
   const navigation = useNavigation<Nav>();
   const [projects, setProjects] = useState<Project[]>([]);
   const [loading, setLoading] = useState(true);
diff --git a/src/app/tabs/ViewChapter.tsx b/src/app/tabs/ViewChapter.tsx
index 64b9917..34a2c32 100644
--- a/src/app/tabs/ViewChapter.tsx
+++ b/src/app/tabs/ViewChapter.tsx
@@ -17,7 +17,7 @@ import { ChapterAssignmentData, VerseData } from '../../types/db/types';
 import { getChapterAssignmentById, getBibleTexts } from '../../db/queries';
 import { useNavigation, useRoute, RouteProp } from '@react-navigation/native';
 
-const log = logger.create('ViewChapterScreen');
+const log = logger.create('ViewChapter');
 
 if (Platform.OS === 'android') {
   UIManager.setLayoutAnimationEnabledExperimental?.(true);
@@ -26,7 +26,7 @@ if (Platform.OS === 'android') {
 type Route = RouteProp<RootStackParamList, 'VerseDetail'>;
 type VerseState = 'idle' | 'recording' | 'recorded';
 
-export default function VerseDetailScreen() {
+export default function ViewChapter() {
   const navigation = useNavigation();
   const { chapterId, chapterName, language, projectName } =
     useRoute<Route>().params;
diff --git a/src/app/tabs/ViewProject.tsx b/src/app/tabs/ViewProject.tsx
index 287204e..cf795af 100644
--- a/src/app/tabs/ViewProject.tsx
+++ b/src/app/tabs/ViewProject.tsx
@@ -18,12 +18,12 @@ import { appStyles as styles } from '../appStyles';
 import { RootStackParamList } from '../../types/navigation/types';
 import { useNavigation, useRoute, RouteProp } from '@react-navigation/native';
 
-const log = logger.create('ChaptersScreen');
+const log = logger.create('ViewProject');
 
 type Nav = StackNavigationProp<RootStackParamList, 'Chapters'>;
 type Route = RouteProp<RootStackParamList, 'Chapters'>;
 
-export default function ChaptersScreen() {
+export default function ViewProject() {
   const navigation = useNavigation<Nav>();
   const { projectId, projectName, language } = useRoute<Route>().params;
 
diff --git a/src/components/ui/SyncButton.tsx b/src/components/ui/SyncButton.tsx
index bdfee46..946afbf 100644
--- a/src/components/ui/SyncButton.tsx
+++ b/src/components/ui/SyncButton.tsx
@@ -55,6 +55,12 @@ export function SyncButton({
   };
 
   const getFailedStep = (): string | null => {
+    const userError = getSyncError(KV_KEYS.SYNC_ERROR_USER);
+    if (userError) return 'user';
+
+    const masterDataError = getSyncError(KV_KEYS.SYNC_ERROR_MASTER_DATA);
+    if (masterDataError) return 'master data';
+
     const projectsError = getSyncError(KV_KEYS.SYNC_ERROR_PROJECTS);
     if (projectsError) return 'projects';
 
diff --git a/src/db/repository.ts b/src/db/repository.ts
index 9c248db..45a7676 100644
--- a/src/db/repository.ts
+++ b/src/db/repository.ts
@@ -5,11 +5,101 @@ import { Transaction } from '@op-engineering/op-sqlite';
 
 const log = logger.create('DBRepository');
 
+async function insertLanguageTx(tx: Transaction, lang: DBTypes.Language) {
+  await tx.execute(
+    `INSERT OR REPLACE INTO languages
+    (id, lang_name, lang_name_localized, lang_code_iso_639_3, script_direction)
+    VALUES (?, ?, ?, ?, ?)`,
+    [
+      lang.id,
+      lang.langName,
+      lang.langNameLocalized ?? null,
+      lang.langCode ?? null,
+      lang.scriptDirection ?? 'ltr',
+    ],
+  );
+}
+
+async function insertBookTx(tx: Transaction, book: DBTypes.Book) {
+  if (!book.eng_display_name) return;
+
+  await tx.execute(
+    `INSERT OR REPLACE INTO books
+    (id, code, eng_display_name)
+    VALUES (?, ?, ?)`,
+    [book.id, book.code, book.eng_display_name],
+  );
+}
+
+async function insertBibleTx(tx: Transaction, bible: DBTypes.Bible) {
+  if (!bible.name || !bible.abbreviation) return;
+
+  await tx.execute(
+    `INSERT OR REPLACE INTO bibles
+    (id, language_id, name, abbreviation)
+    VALUES (?, ?, ?, ?)`,
+    [bible.id, bible.languageId, bible.name, bible.abbreviation],
+  );
+}
+
+async function insertProjectUnitTx(
+  tx: Transaction,
+  unit: { id: number; projectId: number },
+) {
+  await tx.execute(
+    `INSERT OR REPLACE INTO project_units
+    (id, project_id, status)
+    VALUES (?, ?, ?)`,
+    [unit.id, unit.projectId, 'not_started'],
+  );
+}
+
+async function insertChapterAssignmentTx(
+  tx: Transaction,
+  assignment: DBTypes.ChapterAssignment,
+) {
+  if (!assignment?.chapterAssignmentId) return;
+
+  await tx.execute(
+    `INSERT OR REPLACE INTO chapter_assignments
+    (id, project_unit_id, bible_id, book_id, chapter_number,
+     assigned_user_id, status, submitted_time, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      assignment.chapterAssignmentId,
+      assignment.projectUnitId,
+      assignment.bibleId,
+      assignment.bookId,
+      assignment.chapterNumber,
+      assignment.assignedUserId ?? null,
+      assignment.chapterStatus ?? 'not_started',
+      assignment.submittedTime ?? null,
+      assignment.updatedAt ?? new Date().toISOString(),
+    ],
+  );
+}
+
+function getUniqueProjectUnits(assignments: DBTypes.ChapterAssignment[]) {
+  const unitsMap = new Map<number, { id: number; projectId: number }>();
+
+  for (const assignment of assignments) {
+    if (!assignment.projectUnitId || !assignment.projectId) continue;
+    if (unitsMap.has(assignment.projectUnitId)) continue;
+
+    unitsMap.set(assignment.projectUnitId, {
+      id: assignment.projectUnitId,
+      projectId: assignment.projectId,
+    });
+  }
+
+  return unitsMap;
+}
+
 export async function insertUser(user: DBTypes.User) {
   const db = getDatabase();
 
-  try {
-    await db.execute(
+  await db.transaction(async (tx: Transaction) => {
+    await tx.execute(
       `INSERT OR REPLACE INTO users 
       (id, username, email, first_name, last_name)
       VALUES (?, ?, ?, ?, ?)`,
@@ -21,9 +111,7 @@ export async function insertUser(user: DBTypes.User) {
         user.lastName ?? null,
       ],
     );
-  } catch (error) {
-    log.error('Error inserting user', { error });
-  }
+  });
 }
 
 export async function insertLanguages(data: DBTypes.Language[]) {
@@ -31,18 +119,7 @@ export async function insertLanguages(data: DBTypes.Language[]) {
 
   await db.transaction(async (tx: Transaction) => {
     for (const lang of data) {
-      await tx.execute(
-        `INSERT OR REPLACE INTO languages 
-        (id, lang_name, lang_name_localized, lang_code_iso_639_3, script_direction)
-        VALUES (?, ?, ?, ?, ?)`,
-        [
-          lang.id,
-          lang.langName,
-          lang.langNameLocalized ?? null,
-          lang.langCode ?? null,
-          lang.scriptDirection ?? 'ltr',
-        ],
-      );
+      await insertLanguageTx(tx, lang);
     }
   });
 }
@@ -52,14 +129,7 @@ export async function insertBooks(data: DBTypes.Book[]) {
 
   await db.transaction(async (tx: Transaction) => {
     for (const book of data) {
-      if (!book.eng_display_name) continue;
-
-      await tx.execute(
-        `INSERT OR REPLACE INTO books 
-        (id, code, eng_display_name)
-        VALUES (?, ?, ?)`,
-        [book.id, book.code, book.eng_display_name],
-      );
+      await insertBookTx(tx, book);
     }
   });
 }
@@ -69,14 +139,29 @@ export async function insertBibles(data: DBTypes.Bible[]) {
 
   await db.transaction(async (tx: Transaction) => {
     for (const bible of data) {
-      if (!bible.name || !bible.abbreviation) continue;
+      await insertBibleTx(tx, bible);
+    }
+  });
+}
 
-      await tx.execute(
-        `INSERT OR REPLACE INTO bibles 
-        (id, language_id, name, abbreviation)
-        VALUES (?, ?, ?, ?)`,
-        [bible.id, bible.languageId, bible.name, bible.abbreviation],
-      );
+export async function insertMasterData(
+  languages: DBTypes.Language[],
+  books: DBTypes.Book[],
+  bibles: DBTypes.Bible[],
+) {
+  const db = getDatabase();
+
+  await db.transaction(async (tx: Transaction) => {
+    for (const lang of languages) {
+      await insertLanguageTx(tx, lang);
+    }
+
+    for (const book of books) {
+      await insertBookTx(tx, book);
+    }
+
+    for (const bible of bibles) {
+      await insertBibleTx(tx, bible);
     }
   });
 }
@@ -88,8 +173,10 @@ export async function insertProjects(data: DBTypes.Project[]) {
     for (const project of data) {
       if (!project?.id || !project?.name) continue;
 
-      const sourceLangId = project.sourceLanguageId ?? project.sourceLanguageId;
-      const targetLangId = project.targetLanguageId ?? project.targetLanguageId;
+      const sourceLangId =
+        project.sourceLanguageId ?? project.source_language_id;
+      const targetLangId =
+        project.targetLanguageId ?? project.target_language_id;
 
       if (!sourceLangId || !targetLangId) continue;
 
@@ -118,25 +205,7 @@ export async function insertChapterAssignments(
 
   await db.transaction(async (tx: Transaction) => {
     for (const assignment of data) {
-      if (!assignment?.chapterAssignmentId) continue;
-
-      await tx.execute(
-        `INSERT OR REPLACE INTO chapter_assignments 
-        (id, project_unit_id, bible_id, book_id, chapter_number, 
-         assigned_user_id, status, submitted_time, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        [
-          assignment.chapterAssignmentId,
-          assignment.projectUnitId,
-          assignment.bibleId,
-          assignment.bookId,
-          assignment.chapterNumber,
-          assignment.assignedUserId ?? null,
-          assignment.chapterStatus ?? 'not_started',
-          assignment.submittedTime ?? null,
-          assignment.updatedAt ?? new Date().toISOString(),
-        ],
-      );
+      await insertChapterAssignmentTx(tx, assignment);
     }
   });
 }
@@ -146,32 +215,34 @@ export async function insertProjectUnits(
 ) {
   const db = getDatabase();
 
-  const unitsMap = new Map<number, { id: number; projectId: number }>();
-
-  for (const assignment of assignments) {
-    if (!assignment.projectUnitId || !assignment.projectId) continue;
-    if (unitsMap.has(assignment.projectUnitId)) continue;
-
-    unitsMap.set(assignment.projectUnitId, {
-      id: assignment.projectUnitId,
-      projectId: assignment.projectId,
-    });
-  }
+  const unitsMap = getUniqueProjectUnits(assignments);
 
   if (unitsMap.size > 0) {
     await db.transaction(async (tx: Transaction) => {
       for (const unit of unitsMap.values()) {
-        await tx.execute(
-          `INSERT OR REPLACE INTO project_units 
-          (id, project_id, status)
-          VALUES (?, ?, ?)`,
-          [unit.id, unit.projectId, 'not_started'],
-        );
+        await insertProjectUnitTx(tx, unit);
       }
     });
   }
 }
 
+export async function insertChapterAssignmentSyncData(
+  assignments: DBTypes.ChapterAssignment[],
+) {
+  const db = getDatabase();
+  const unitsMap = getUniqueProjectUnits(assignments);
+
+  await db.transaction(async (tx: Transaction) => {
+    for (const unit of unitsMap.values()) {
+      await insertProjectUnitTx(tx, unit);
+    }
+
+    for (const assignment of assignments) {
+      await insertChapterAssignmentTx(tx, assignment);
+    }
+  });
+}
+
 export async function getChaptersToSync() {
   const db = getDatabase();
 
diff --git a/src/db/schema.ts b/src/db/schema.ts
index 31a1f98..d607163 100644
--- a/src/db/schema.ts
+++ b/src/db/schema.ts
@@ -40,7 +40,7 @@ export const createTableQueries: string[] = [
 
   `CREATE TABLE IF NOT EXISTS project_units (
       id         INTEGER PRIMARY KEY,
-      project_id INTEGER NOT NULL,
+      project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
       status     TEXT NOT NULL DEFAULT 'not_started',
       updated_at TEXT 
     );`,
@@ -49,7 +49,7 @@ export const createTableQueries: string[] = [
 
   ` CREATE TABLE IF NOT EXISTS chapter_assignments (
       id               INTEGER PRIMARY KEY,
-      project_unit_id  INTEGER NOT NULL REFERENCES project_units(id),
+      project_unit_id INTEGER NOT NULL REFERENCES project_units(id) ON DELETE CASCADE,
       bible_id         INTEGER NOT NULL REFERENCES bibles(id),
       book_id          INTEGER NOT NULL REFERENCES books(id),
       chapter_number   INTEGER NOT NULL,
@@ -78,7 +78,7 @@ export const createTableQueries: string[] = [
   `CREATE TABLE IF NOT EXISTS recordings (
       id                    TEXT PRIMARY KEY,
       bible_text_id         INTEGER NOT NULL REFERENCES bible_texts(id),
-      chapter_assignment_id INTEGER NOT NULL REFERENCES chapter_assignments(id),
+      chapter_assignment_id INTEGER NOT NULL REFERENCES chapter_assignments(id) ON DELETE CASCADE,
       assigned_user_id      INTEGER NOT NULL REFERENCES users(id),
       local_file_path       TEXT NOT NULL,
       blob_key              TEXT,
diff --git a/src/navigation/AppNavigator.tsx b/src/navigation/AppNavigator.tsx
index 28bfc7e..40206d1 100644
--- a/src/navigation/AppNavigator.tsx
+++ b/src/navigation/AppNavigator.tsx
@@ -3,7 +3,7 @@ import { createStackNavigator } from '@react-navigation/stack';
 import { RootStackParamList } from '../types/navigation/types';
 import ProjectList from '../app/tabs/ProjectList';
 import ViewProject from '../app/tabs/ViewProject';
-import VerseDetailScreen from '../app/tabs/ViewChapter';
+import ViewChapter from '../app/tabs/ViewChapter';
 
 const Stack = createStackNavigator<RootStackParamList>();
 
@@ -12,7 +12,7 @@ export default function AppNavigator() {
     <Stack.Navigator screenOptions={{ headerShown: false }}>
       <Stack.Screen name="Projects" component={ProjectList} />
       <Stack.Screen name="Chapters" component={ViewProject} />
-      <Stack.Screen name="VerseDetail" component={VerseDetailScreen} />
+      <Stack.Screen name="VerseDetail" component={ViewChapter} />
     </Stack.Navigator>
   );
 }
diff --git a/src/services/storage.ts b/src/services/storage.ts
index 47a476c..848271d 100644
--- a/src/services/storage.ts
+++ b/src/services/storage.ts
@@ -15,6 +15,8 @@ export const KV_KEYS = {
   SYNC_COUNT_PROJECTS: 'sync_count_projects',
   SYNC_COUNT_CHAPTERS: 'sync_count_chapters',
   SYNC_COUNT_BIBLES: 'sync_count_bibles',
+  SYNC_ERROR_USER: 'sync_error_user',
+  SYNC_ERROR_MASTER_DATA: 'sync_error_master_data',
   SYNC_ERROR_PROJECTS: 'sync_error_projects',
   SYNC_ERROR_CHAPTER_ASSIGNMENTS: 'sync_error_chapter_assignments',
   SYNC_ERROR_PROJECT_UNITS: 'sync_error_project_units',
@@ -79,6 +81,8 @@ export function clearSyncError(key: (typeof KV_KEYS)[keyof typeof KV_KEYS]) {
 }
 
 export function clearAllSyncErrors() {
+  clearSyncError(KV_KEYS.SYNC_ERROR_USER);
+  clearSyncError(KV_KEYS.SYNC_ERROR_MASTER_DATA);
   clearSyncError(KV_KEYS.SYNC_ERROR_PROJECTS);
   clearSyncError(KV_KEYS.SYNC_ERROR_CHAPTER_ASSIGNMENTS);
   clearSyncError(KV_KEYS.SYNC_ERROR_PROJECT_UNITS);
diff --git a/src/services/sync.ts b/src/services/sync.ts
index 5784cd7..4b33858 100644
--- a/src/services/sync.ts
+++ b/src/services/sync.ts
@@ -1,12 +1,9 @@
 import { FluentAPI } from './api';
 import {
   insertUser,
-  insertLanguages,
-  insertBooks,
-  insertBibles,
+  insertMasterData,
   insertProjects,
-  insertChapterAssignments,
-  insertProjectUnits,
+  insertChapterAssignmentSyncData,
   insertBibleTexts,
   getChaptersToSync,
 } from '../db/repository';
@@ -19,13 +16,61 @@ import {
   setLastSyncedAt,
   KV_KEYS,
   setSyncError,
+  clearSyncError,
+  clearAllSyncErrors,
 } from '../services/storage';
 
 const log = logger.create('SyncService');
 const db = getDatabase();
 
+const MAX_SYNC_ATTEMPTS = 3;
+
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function retrySyncStep<T>(
+  stepName: string,
+  errorKey: (typeof KV_KEYS)[keyof typeof KV_KEYS],
+  operation: () => Promise<T>,
+): Promise<T> {
+  let lastError: unknown;
+
+  for (let attempt = 1; attempt <= MAX_SYNC_ATTEMPTS; attempt += 1) {
+    try {
+      const result = await operation();
+      clearSyncError(errorKey);
+      return result;
+    } catch (error) {
+      lastError = error;
+      const errorMessage = getErrorMessage(error);
+
+      if (attempt === MAX_SYNC_ATTEMPTS) {
+        log.error(`${stepName} failed after ${MAX_SYNC_ATTEMPTS} attempts`, {
+          error: errorMessage,
+        });
+        setSyncError(errorKey, errorMessage);
+        break;
+      }
+
+      log.warn(`${stepName} failed, retrying`, {
+        attempt,
+        maxAttempts: MAX_SYNC_ATTEMPTS,
+        error: errorMessage,
+      });
+      await delay(attempt * 500);
+    }
+  }
+
+  throw lastError;
+}
+
 export async function syncUser(email: string) {
-  try {
+  return retrySyncStep('User sync', KV_KEYS.SYNC_ERROR_USER, async () => {
     log.info('Syncing user...');
 
     const user = await FluentAPI.getUserByEmail(email);
@@ -39,101 +84,100 @@ export async function syncUser(email: string) {
     setUserSync(String(user.id), user.email);
     log.info('User synced', { email: user.email });
     return user;
-  } catch (error) {
-    log.error('User sync failed', { error });
-    throw error;
-  }
+  });
 }
 
 export async function syncMasterData() {
-  try {
-    log.info('Sync started');
-
-    const [languages, books, bibles] = await Promise.all([
-      FluentAPI.getLanguages(),
-      FluentAPI.getBooks(),
-      FluentAPI.getBibles(),
-    ]);
-
-    await insertLanguages(languages);
-    await insertBooks(books);
-    await insertBibles(bibles);
-
-    log.info('Sync completed');
-  } catch (error) {
-    log.error('Sync failed', { error });
-  }
+  return retrySyncStep(
+    'Master data sync',
+    KV_KEYS.SYNC_ERROR_MASTER_DATA,
+    async () => {
+      log.info('Sync started');
+
+      const [languages, books, bibles] = await Promise.all([
+        FluentAPI.getLanguages(),
+        FluentAPI.getBooks(),
+        FluentAPI.getBibles(),
+      ]);
+
+      await insertMasterData(languages, books, bibles);
+
+      log.info('Sync completed');
+    },
+  );
 }
 
 export async function syncProjects(userId: number, email: string) {
-  try {
-    log.info('Syncing projects...');
-
-    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) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    log.error('Project sync failed', { error: errorMessage });
-    setSyncError(KV_KEYS.SYNC_ERROR_PROJECTS, errorMessage);
-  }
+  return retrySyncStep(
+    'Project sync',
+    KV_KEYS.SYNC_ERROR_PROJECTS,
+    async () => {
+      log.info('Syncing projects...');
+
+      const projects = await FluentAPI.getUserProjects(userId, email);
+
+      await insertProjects(projects);
+      const db = getDatabase();
+      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 });
+    },
+  );
 }
 
 export async function syncChapterAssignments(userId: number, email: string) {
-  try {
-    log.info('Syncing chapter assignments...');
+  return retrySyncStep(
+    'Chapter assignment sync',
+    KV_KEYS.SYNC_ERROR_CHAPTER_ASSIGNMENTS,
+    async () => {
+      log.info('Syncing chapter assignments...');
 
-    const response = await FluentAPI.getChapterAssignments(userId, email);
+      const response = await FluentAPI.getChapterAssignments(userId, email);
 
-    const allAssignments = [
-      ...(response?.assignedChapters || []),
-      ...(response?.peerCheckChapters || []),
-    ];
+      const allAssignments = [
+        ...(response?.assignedChapters || []),
+        ...(response?.peerCheckChapters || []),
+      ];
 
-    if (allAssignments.length > 0) {
-      await insertProjectUnits(allAssignments);
+      if (allAssignments.length > 0) {
+        await insertChapterAssignmentSyncData(allAssignments);
 
-      await insertChapterAssignments(allAssignments);
-
-      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));
+        const db = getDatabase();
+        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) {
-    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);
-  }
+        log.info('Chapter assignments synced', {
+          apiCount: allAssignments.length,
+          totalInDb: totalChaptersCount,
+        });
+      }
+    },
+  );
 }
 
 export async function syncBibleTexts(email: string) {
-  try {
-    log.info('Syncing bible texts...');
-
-    const bibleGroups = await getChaptersToSync();
-
-    if (bibleGroups.size === 0) {
-      log.info('No chapters to sync');
-      setSyncCount(KV_KEYS.SYNC_COUNT_BIBLES, 0);
-      return 0;
-    }
+  return retrySyncStep(
+    'Bible text sync',
+    KV_KEYS.SYNC_ERROR_BIBLE_TEXTS,
+    async () => {
+      log.info('Syncing bible texts...');
+
+      const bibleGroups = await getChaptersToSync();
+
+      if (bibleGroups.size === 0) {
+        log.info('No chapters to sync');
+        setSyncCount(KV_KEYS.SYNC_COUNT_BIBLES, 0);
+        return 0;
+      }
 
-    let totalTextsInserted = 0;
+      let totalTextsInserted = 0;
 
-    for (const [bibleId, chapters] of bibleGroups) {
-      try {
+      for (const [bibleId, chapters] of bibleGroups) {
         log.info('Syncing chapters for bible', {
           bibleId,
           chapterCount: chapters.length,
@@ -145,55 +189,50 @@ export async function syncBibleTexts(email: string) {
           email,
         );
 
-        if (response && Array.isArray(response)) {
-          const textsWithBibleId = response.map((book: ApiBook) => ({
-            bookId: book.bookId,
-            chapterNumber: book.chapterNumber,
-            verses: book.verses.map((verse: ApiVerse) => ({
-              bible_id: bibleId,
-              book_id: book.bookId,
-              chapter_number: book.chapterNumber,
-              verse_number: verse.verseNumber,
-              text: verse.text,
-            })),
-          }));
-
-          await insertBibleTexts(textsWithBibleId);
-          totalTextsInserted += response.length;
-          log.info('Synced books for bible', {
-            bibleId,
-            count: response.length,
-          });
+        if (!Array.isArray(response)) {
+          throw new Error(`Invalid bible text response for bible ${bibleId}`);
         }
-      } catch (error) {
-        const errorMessage =
-          error instanceof Error ? error.message : String(error);
-        log.error(`Failed to sync texts for bible ${bibleId}:`, {
-          error: errorMessage,
+
+        const textsWithBibleId = response.map((book: ApiBook) => ({
+          bookId: book.bookId,
+          chapterNumber: book.chapterNumber,
+          verses: book.verses.map((verse: ApiVerse) => ({
+            bible_id: bibleId,
+            book_id: book.bookId,
+            chapter_number: book.chapterNumber,
+            verse_number: verse.verseNumber,
+            text: verse.text,
+          })),
+        }));
+
+        await insertBibleTexts(textsWithBibleId);
+        totalTextsInserted += textsWithBibleId.reduce(
+          (count, book) => count + book.verses.length,
+          0,
+        );
+        log.info('Synced books for bible', {
+          bibleId,
+          count: response.length,
         });
-        setSyncError(KV_KEYS.SYNC_ERROR_BIBLE_TEXTS, errorMessage);
-        continue;
       }
-    }
-    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) {
-    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);
-  }
+      const db = getDatabase();
+      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,
+      });
+    },
+  );
 }
 
 export async function syncAllData(email: string) {
   log.info('Starting full sync...');
+  clearAllSyncErrors();
 
   try {
     const user = await syncUser(email);
@@ -204,17 +243,14 @@ export async function syncAllData(email: string) {
 
     await syncChapterAssignments(user.id, email);
 
-    try {
-      await syncBibleTexts(email);
-    } catch (e) {
-      log.warn('Bible text sync failed, continuing...', { error: e });
-    }
+    await syncBibleTexts(email);
+
     const now = new Date().toISOString();
     setLastSyncedAt(now);
 
     log.info('Full sync completed successfully!', { timestamp: now });
   } catch (error) {
-    log.error('Full sync failed', { error });
+    log.error('Full sync failed', { error: getErrorMessage(error) });
     throw error;
   }
 }
diff --git a/src/types/db/types.ts b/src/types/db/types.ts
index d62472e..1025c43 100644
--- a/src/types/db/types.ts
+++ b/src/types/db/types.ts
@@ -15,8 +15,10 @@ export interface Project {
   id: number;
   name: string;
   sourceLanguageId?: number;
+  source_language_id?: number;
   source_language_name?: string;
   targetLanguageId?: number;
+  target_language_id?: number;
   target_language_name: string;
   isActive?: boolean;
   status?: string;