diff --git a/formulus/src/components/AutoSyncSettings.tsx b/formulus/src/components/AutoSyncSettings.tsx
new file mode 100644
index 000000000..97946bc1d
--- /dev/null
+++ b/formulus/src/components/AutoSyncSettings.tsx
@@ -0,0 +1,214 @@
+import React, { useCallback, useState } from 'react';
+import { StyleSheet, Switch, Text, TouchableOpacity, View } from 'react-native';
+import { useFocusEffect } from '@react-navigation/native';
+import { useTranslation } from 'react-i18next';
+import { useAppTheme } from '../contexts/AppThemeContext';
+import {
+  AUTO_SYNC_INTERVALS,
+  type AutoSyncInterval,
+  loadAutoSyncSettings,
+  saveAutoSyncSettings,
+} from '../services/AutoSyncSettingsService';
+import { autoSyncService } from '../services/AutoSyncService';
+import { ToastService } from '../services/ToastService';
+import { odeSpacing, odeTypography } from '../theme/odeDesign';
+import { withAlpha } from '../theme/colors';
+
+const intervalLabelKey = (interval: AutoSyncInterval): string => {
+  switch (interval) {
+    case 30_000:
+      return 'profiles.autoSync30Seconds';
+    case 2 * 60_000:
+      return 'profiles.autoSync2Minutes';
+    case 5 * 60_000:
+      return 'profiles.autoSync5Minutes';
+    case 15 * 60_000:
+      return 'profiles.autoSync15Minutes';
+    case 60 * 60_000:
+      return 'profiles.autoSync1Hour';
+    case 24 * 60 * 60_000:
+      return 'profiles.autoSync24Hours';
+  }
+  return 'profiles.autoSync5Minutes';
+};
+
+const AutoSyncSettings = () => {
+  const { t } = useTranslation();
+  const { themeColors } = useAppTheme();
+  const [enabled, setEnabled] = useState(false);
+  const [intervalMs, setIntervalMs] = useState<AutoSyncInterval>(5 * 60_000);
+  const [loading, setLoading] = useState(true);
+
+  useFocusEffect(
+    useCallback(() => {
+      let cancelled = false;
+
+      setLoading(true);
+
+      void loadAutoSyncSettings()
+        .then(settings => {
+          if (cancelled) return;
+
+          setEnabled(settings.enabled);
+          setIntervalMs(settings.intervalMs);
+        })
+        .catch(() => {
+          if (!cancelled) {
+            ToastService.showLong(t('profiles.autoSyncLoadFailed'));
+          }
+        })
+        .finally(() => {
+          if (!cancelled) {
+            setLoading(false);
+          }
+        });
+
+      return () => {
+        cancelled = true;
+      };
+    }, [t]),
+  );
+
+  const save = async (
+    nextEnabled: boolean,
+    nextInterval: AutoSyncInterval,
+  ): Promise<void> => {
+    try {
+      await saveAutoSyncSettings({
+        enabled: nextEnabled,
+        intervalMs: nextInterval,
+      });
+
+      autoSyncService.refresh();
+    } catch {
+      ToastService.showLong(t('profiles.autoSyncSaveFailed'));
+    }
+  };
+
+  const handleEnabledChange = (value: boolean) => {
+    setEnabled(value);
+    void save(value, intervalMs);
+  };
+
+  const handleIntervalChange = (value: AutoSyncInterval) => {
+    setIntervalMs(value);
+    void save(enabled, value);
+  };
+
+  return (
+    <View style={styles.section}>
+      <View style={styles.toggleRow}>
+        <View style={styles.toggleText}>
+          <Text style={[styles.heading, { color: themeColors.onSurface }]}>
+            {t('profiles.autoSyncTitle')}
+          </Text>
+          <Text style={[styles.hint, { color: themeColors.onSurface }]}>
+            {t('profiles.autoSyncHint')}
+          </Text>
+        </View>
+
+        <Switch
+          value={enabled}
+          disabled={loading}
+          onValueChange={handleEnabledChange}
+          accessibilityLabel={t('profiles.autoSyncTitle')}
+        />
+      </View>
+
+      {enabled && (
+        <View style={styles.intervalSection}>
+          <Text
+            style={[styles.intervalTitle, { color: themeColors.onSurface }]}>
+            {t('profiles.autoSyncInterval')}
+          </Text>
+
+          <View style={styles.intervalOptions}>
+            {AUTO_SYNC_INTERVALS.map(interval => {
+              const selected = intervalMs === interval;
+
+              return (
+                <TouchableOpacity
+                  key={interval}
+                  accessibilityRole="radio"
+                  accessibilityState={{ checked: selected, disabled: loading }}
+                  disabled={loading}
+                  onPress={() => handleIntervalChange(interval)}
+                  style={[
+                    styles.intervalOption,
+                    {
+                      backgroundColor: withAlpha(
+                        themeColors.primary as string,
+                        selected ? 0.12 : 0,
+                      ),
+                    },
+                  ]}>
+                  <Text
+                    style={[
+                      styles.intervalText,
+                      {
+                        color: selected
+                          ? themeColors.primary
+                          : themeColors.onSurface,
+                      },
+                    ]}>
+                    {t(intervalLabelKey(interval))}
+                  </Text>
+                </TouchableOpacity>
+              );
+            })}
+          </View>
+        </View>
+      )}
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  section: {
+    marginTop: odeSpacing.md,
+    gap: odeSpacing.sm,
+  },
+  toggleRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    gap: odeSpacing.md,
+  },
+  toggleText: {
+    flex: 1,
+  },
+  heading: {
+    fontSize: odeTypography.sectionTitle,
+    fontWeight: '600',
+  },
+  hint: {
+    fontSize: odeTypography.bodySm,
+    marginTop: odeSpacing.xs,
+  },
+  intervalSection: {
+    gap: odeSpacing.sm,
+  },
+  intervalTitle: {
+    fontSize: odeTypography.body,
+    fontWeight: '600',
+  },
+  intervalOptions: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+    gap: odeSpacing.xs,
+  },
+  intervalOption: {
+    borderWidth: 1,
+    borderRadius: odeSpacing.xs,
+    paddingHorizontal: odeSpacing.sm,
+    paddingVertical: odeSpacing.xs,
+    minHeight: 44,
+    justifyContent: 'center',
+  },
+  intervalText: {
+    fontSize: odeTypography.bodySm,
+    fontWeight: '500',
+  },
+});
+
+export default AutoSyncSettings;
diff --git a/formulus/src/locales/en.json b/formulus/src/locales/en.json
index d12013c7c..049d3be19 100644
--- a/formulus/src/locales/en.json
+++ b/formulus/src/locales/en.json
@@ -55,6 +55,17 @@
   "profiles.showPassword": "Show password",
   "profiles.hidePassword": "Hide password",
   "profiles.working": "Working…",
+  "profiles.autoSyncTitle": "Automatic sync",
+  "profiles.autoSyncHint": "Automatically sync observations while Formulus is open.",
+  "profiles.autoSyncInterval": "Sync interval",
+  "profiles.autoSync30Seconds": "Every 30 seconds",
+  "profiles.autoSync2Minutes": "Every 2 minutes",
+  "profiles.autoSync5Minutes": "Every 5 minutes",
+  "profiles.autoSync15Minutes": "Every 15 minutes",
+  "profiles.autoSync1Hour": "Every hour",
+  "profiles.autoSync24Hours": "Every 24 hours",
+  "profiles.autoSyncLoadFailed": "Could not load automatic sync settings.",
+  "profiles.autoSyncSaveFailed": "Could not save automatic sync settings.",
   "welcome.title": "Welcome to:",
   "welcome.profilesSubtitle": "Set up a profile to connect to your server.",
   "welcome.getStarted": "Get started",
diff --git a/formulus/src/locales/fr.json b/formulus/src/locales/fr.json
index 6a3e1f37b..7c9572eaa 100644
--- a/formulus/src/locales/fr.json
+++ b/formulus/src/locales/fr.json
@@ -55,6 +55,17 @@
   "profiles.showPassword": "Afficher le mot de passe",
   "profiles.hidePassword": "Masquer le mot de passe",
   "profiles.working": "Traitement…",
+  "profiles.autoSyncTitle": "Synchronisation automatique",
+  "profiles.autoSyncHint": "Synchronise automatiquement les observations lorsque Formulus est ouvert.",
+  "profiles.autoSyncInterval": "Intervalle de synchronisation",
+  "profiles.autoSync30Seconds": "Toutes les 30 secondes",
+  "profiles.autoSync2Minutes": "Toutes les 2 minutes",
+  "profiles.autoSync5Minutes": "Toutes les 5 minutes",
+  "profiles.autoSync15Minutes": "Toutes les 15 minutes",
+  "profiles.autoSync1Hour": "Toutes les heures",
+  "profiles.autoSync24Hours": "Toutes les 24 heures",
+  "profiles.autoSyncLoadFailed": "Impossible de charger les paramètres de synchronisation automatique.",
+  "profiles.autoSyncSaveFailed": "Impossible d’enregistrer les paramètres de synchronisation automatique.",
   "welcome.title": "Bienvenue dans :",
   "welcome.profilesSubtitle": "Configurez un profil pour vous connecter à votre serveur.",
   "welcome.getStarted": "Commencer",
diff --git a/formulus/src/locales/pt.json b/formulus/src/locales/pt.json
index a64ca54cb..5903cfb7e 100644
--- a/formulus/src/locales/pt.json
+++ b/formulus/src/locales/pt.json
@@ -55,6 +55,17 @@
   "profiles.showPassword": "Mostrar palavra-passe",
   "profiles.hidePassword": "Ocultar palavra-passe",
   "profiles.working": "A processar…",
+  "profiles.autoSyncTitle": "Sincronização automática",
+  "profiles.autoSyncHint": "Sincroniza automaticamente as observações enquanto o Formulus está aberto.",
+  "profiles.autoSyncInterval": "Intervalo de sincronização",
+  "profiles.autoSync30Seconds": "A cada 30 segundos",
+  "profiles.autoSync2Minutes": "A cada 2 minutos",
+  "profiles.autoSync5Minutes": "A cada 5 minutos",
+  "profiles.autoSync15Minutes": "A cada 15 minutos",
+  "profiles.autoSync1Hour": "A cada hora",
+  "profiles.autoSync24Hours": "A cada 24 horas",
+  "profiles.autoSyncLoadFailed": "Não foi possível carregar as definições de sincronização automática.",
+  "profiles.autoSyncSaveFailed": "Não foi possível guardar as definições de sincronização automática.",
   "welcome.title": "Bem-vindo ao:",
   "welcome.profilesSubtitle": "Configure um perfil para se ligar ao seu servidor.",
   "welcome.getStarted": "Começar",
diff --git a/formulus/src/profiles/ProfileRoot.tsx b/formulus/src/profiles/ProfileRoot.tsx
index 3db642335..87132e9ee 100644
--- a/formulus/src/profiles/ProfileRoot.tsx
+++ b/formulus/src/profiles/ProfileRoot.tsx
@@ -7,6 +7,7 @@ import React, {
 import { ActivityIndicator, StyleSheet, Text, View } from 'react-native';
 import { bootstrapProfileApp } from './ProfileBootstrap';
 import { i18n } from '../i18n';
+import { autoSyncService } from '../services/AutoSyncService';
 import {
   getProfileTransitionState,
   registerProfileTransitionHost,
@@ -49,6 +50,19 @@ export default function ProfileRoot(): React.JSX.Element {
     };
   }, []);
 
+  useEffect(() => {
+    if (!AppComponent || unmounted || transition !== 'idle' || error) {
+      autoSyncService.stop();
+      return;
+    }
+
+    const stopAutoSync = autoSyncService.start();
+
+    return () => {
+      stopAutoSync();
+    };
+  }, [AppComponent, unmounted, transition, error]);
+
   useEffect(
     () =>
       registerProfileTransitionHost({
diff --git a/formulus/src/screens/ProfileConnection.tsx b/formulus/src/screens/ProfileConnection.tsx
index 6ab41d304..41bd1c121 100644
--- a/formulus/src/screens/ProfileConnection.tsx
+++ b/formulus/src/screens/ProfileConnection.tsx
@@ -5,6 +5,7 @@ import type { BottomTabNavigationProp } from '@react-navigation/bottom-tabs';
 import Icon from '@react-native-vector-icons/material-design-icons';
 import { useTranslation } from 'react-i18next';
 import { Button, Input } from '../components/common';
+import AutoSyncSettings from '../components/AutoSyncSettings';
 import QRScannerModal, {
   ScannerModalResults,
 } from '../components/QRScannerModal';
@@ -423,6 +424,9 @@ const ProfileConnection = ({
           </TouchableOpacity>
         }
       />
+
+      {!creation && <AutoSyncSettings />}
+
       {creation ? (
         <View style={styles.actions}>
           <Button
diff --git a/formulus/src/screens/__tests__/ProfilesScreen.test.tsx b/formulus/src/screens/__tests__/ProfilesScreen.test.tsx
index 52fe39363..41aa8edc3 100644
--- a/formulus/src/screens/__tests__/ProfilesScreen.test.tsx
+++ b/formulus/src/screens/__tests__/ProfilesScreen.test.tsx
@@ -129,6 +129,10 @@ jest.mock('react-native-safe-area-context', () => ({
   },
 }));
 jest.mock('@react-native-vector-icons/material-design-icons', () => 'Icon');
+jest.mock('../../components/AutoSyncSettings', () => ({
+  __esModule: true,
+  default: () => null,
+}));
 jest.mock('../../contexts/AppThemeContext', () => ({
   useAppTheme: () => ({
     themeColors: {
diff --git a/formulus/src/services/AutoSyncService.ts b/formulus/src/services/AutoSyncService.ts
new file mode 100644
index 000000000..6523b203e
--- /dev/null
+++ b/formulus/src/services/AutoSyncService.ts
@@ -0,0 +1,141 @@
+import { AppState, type AppStateStatus } from 'react-native';
+import { getActiveProfile } from '../profiles/ProfileRuntime';
+import { loadAutoSyncSettings } from './AutoSyncSettingsService';
+import { syncService } from './SyncService';
+
+export class AutoSyncService {
+  private static instance: AutoSyncService;
+
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private appState: AppStateStatus = AppState.currentState;
+  private started = false;
+  private generation = 0;
+
+  private constructor() {}
+
+  public static getInstance(): AutoSyncService {
+    if (!AutoSyncService.instance) {
+      AutoSyncService.instance = new AutoSyncService();
+    }
+
+    return AutoSyncService.instance;
+  }
+
+  public start(): () => void {
+    if (this.started) {
+      return () => undefined;
+    }
+
+    this.started = true;
+
+    const subscription = AppState.addEventListener(
+      'change',
+      this.handleAppStateChange,
+    );
+
+    void this.scheduleNext();
+
+    return () => {
+      subscription.remove();
+      this.stop();
+    };
+  }
+
+  public stop(): void {
+    this.started = false;
+    this.generation += 1;
+    this.clearTimer();
+  }
+
+  public refresh(): void {
+    this.generation += 1;
+    this.clearTimer();
+
+    if (this.started && this.appState === 'active') {
+      void this.scheduleNext();
+    }
+  }
+
+  private readonly handleAppStateChange = (nextState: AppStateStatus): void => {
+    this.appState = nextState;
+    this.generation += 1;
+    this.clearTimer();
+
+    if (nextState === 'active' && this.started) {
+      void this.scheduleNext();
+    }
+  };
+
+  private async scheduleNext(): Promise<void> {
+    const generation = ++this.generation;
+
+    if (!this.started || this.appState !== 'active') {
+      return;
+    }
+
+    const profileId = getActiveProfile().id;
+    const settings = await loadAutoSyncSettings();
+
+    if (
+      generation !== this.generation ||
+      !this.started ||
+      this.appState !== 'active' ||
+      getActiveProfile().id !== profileId ||
+      !settings.enabled
+    ) {
+      return;
+    }
+
+    this.timer = setTimeout(() => {
+      void this.runScheduledSync(profileId, generation);
+    }, settings.intervalMs);
+  }
+
+  private async runScheduledSync(
+    profileId: string,
+    generation: number,
+  ): Promise<void> {
+    this.timer = null;
+
+    if (
+      generation !== this.generation ||
+      !this.started ||
+      this.appState !== 'active' ||
+      getActiveProfile().id !== profileId
+    ) {
+      return;
+    }
+
+    if (syncService.getIsSyncing()) {
+      await this.scheduleNext();
+      return;
+    }
+
+    try {
+      await syncService.syncObservations({
+        includeAttachments: false,
+        silent: true,
+      });
+    } catch {
+      // Auto-sync failures are intentionally silent. Status UI will surface
+      // the result without using manual-sync notifications or modals.
+    }
+
+    if (
+      this.started &&
+      this.appState === 'active' &&
+      getActiveProfile().id === profileId
+    ) {
+      await this.scheduleNext();
+    }
+  }
+
+  private clearTimer(): void {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+}
+
+export const autoSyncService = AutoSyncService.getInstance();
diff --git a/formulus/src/services/AutoSyncSettingsService.ts b/formulus/src/services/AutoSyncSettingsService.ts
new file mode 100644
index 000000000..05345ae89
--- /dev/null
+++ b/formulus/src/services/AutoSyncSettingsService.ts
@@ -0,0 +1,61 @@
+import ProfileStorage from '../profiles/ProfileStorage';
+
+const AUTO_SYNC_SETTINGS_KEY = '@auto_sync_settings';
+
+export const AUTO_SYNC_INTERVALS = [
+  30_000,
+  2 * 60_000,
+  5 * 60_000,
+  15 * 60_000,
+  60 * 60_000,
+  24 * 60 * 60_000,
+] as const;
+
+export type AutoSyncInterval = (typeof AUTO_SYNC_INTERVALS)[number];
+
+export type AutoSyncSettings = {
+  enabled: boolean;
+  intervalMs: AutoSyncInterval;
+};
+
+export const DEFAULT_AUTO_SYNC_SETTINGS: AutoSyncSettings = {
+  enabled: false,
+  intervalMs: 5 * 60_000,
+};
+
+const isAutoSyncInterval = (value: unknown): value is AutoSyncInterval =>
+  typeof value === 'number' &&
+  AUTO_SYNC_INTERVALS.some(interval => interval === value);
+
+export async function loadAutoSyncSettings(): Promise<AutoSyncSettings> {
+  const raw = await ProfileStorage.getItem(AUTO_SYNC_SETTINGS_KEY);
+
+  if (!raw) {
+    return { ...DEFAULT_AUTO_SYNC_SETTINGS };
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as Partial<AutoSyncSettings>;
+
+    return {
+      enabled:
+        typeof parsed.enabled === 'boolean'
+          ? parsed.enabled
+          : DEFAULT_AUTO_SYNC_SETTINGS.enabled,
+      intervalMs: isAutoSyncInterval(parsed.intervalMs)
+        ? parsed.intervalMs
+        : DEFAULT_AUTO_SYNC_SETTINGS.intervalMs,
+    };
+  } catch {
+    return { ...DEFAULT_AUTO_SYNC_SETTINGS };
+  }
+}
+
+export async function saveAutoSyncSettings(
+  settings: AutoSyncSettings,
+): Promise<void> {
+  await ProfileStorage.setItem(
+    AUTO_SYNC_SETTINGS_KEY,
+    JSON.stringify(settings),
+  );
+}
diff --git a/formulus/src/services/SyncService.ts b/formulus/src/services/SyncService.ts
index 3c3513c79..5817355d7 100644
--- a/formulus/src/services/SyncService.ts
+++ b/formulus/src/services/SyncService.ts
@@ -35,6 +35,11 @@ import { isCancelledError } from '../sync/transientRetry';
 type SyncStatusCallback = (status: string) => void;
 type SyncProgressDetailCallback = (progress: SyncProgress) => void;
 
+type SyncObservationsOptions = {
+  includeAttachments?: boolean;
+  silent?: boolean;
+};
+
 type SyncOutcome =
   | { kind: 'success'; finalVersion: number }
   | {
@@ -79,9 +84,16 @@ export class SyncService {
     this.statusCallbacks.forEach(callback => callback(status));
   }
 
-  private updateProgress(progress: SyncProgress): void {
+  private updateProgress(progress: SyncProgress, silent = false): void {
+    // Always update subscribers, including silent auto-sync.
     this.progressCallbacks.forEach(callback => callback(progress));
-    // Note: showSyncProgress is now async, but we don't await to avoid blocking sync
+
+    // Silent sync must not create progress notifications.
+    if (silent) {
+      return;
+    }
+
+    // Note: showSyncProgress is async, but we don't await to avoid blocking sync
     profileActivity
       .run('Sync notification', () =>
         notificationService.showSyncProgress(progress),
@@ -217,14 +229,25 @@ export class SyncService {
     }
   }
 
-  public async syncObservations(includeAttachments = false): Promise<number> {
+  public async syncObservations(
+    includeAttachmentsOrOptions: boolean | SyncObservationsOptions = false,
+  ): Promise<number> {
+    const options: SyncObservationsOptions =
+      typeof includeAttachmentsOrOptions === 'boolean'
+        ? { includeAttachments: includeAttachmentsOrOptions }
+        : includeAttachmentsOrOptions;
+
     return profileActivity.run('Sync observations', () =>
-      this.syncObservationsImpl(includeAttachments),
+      this.syncObservationsImpl(
+        options.includeAttachments ?? false,
+        options.silent ?? false,
+      ),
     );
   }
 
   private async syncObservationsImpl(
     includeAttachments: boolean,
+    silent: boolean,
   ): Promise<number> {
     if (this.isSyncing) {
       throw new Error('Sync already in progress');
@@ -236,35 +259,44 @@ export class SyncService {
     this.autoLoginRetryCount = 0;
     this.updateStatus('Starting sync...');
 
-    profileActivity
-      .run('Clear sync notifications', () =>
-        notificationService.clearAllSyncNotifications(),
-      )
-      .catch(error =>
-        logger.warn(
-          'sync',
-          error instanceof Error
-            ? error.message
-            : 'Failed to clear stale notifications',
-        ),
-      );
+    if (!silent) {
+      profileActivity
+        .run('Clear sync notifications', () =>
+          notificationService.clearAllSyncNotifications(),
+        )
+        .catch(error =>
+          logger.warn(
+            'sync',
+            error instanceof Error
+              ? error.message
+              : 'Failed to clear stale notifications',
+          ),
+        );
+    }
 
     try {
       await logger.breadcrumb('sync', 'start');
-      await notificationService.startForegroundService();
+
+      if (!silent) {
+        await notificationService.startForegroundService();
+      }
+      if (this.shouldCancel) throw new Error('Sync cancelled');
 
       const syncOptions: SynkronusSyncOptions = {
-        onProgress: progress => this.updateProgress(progress),
+        onProgress: progress => this.updateProgress(progress, silent),
         isCancelled: () => this.shouldCancel,
       };
 
-      this.updateProgress({
-        current: 0,
-        total: 0,
-        phase: 'pull_observations',
-        indeterminate: true,
-        details: i18n.t('sync.progress.starting'),
-      });
+      this.updateProgress(
+        {
+          current: 0,
+          total: 0,
+          phase: 'pull_observations',
+          indeterminate: true,
+          details: i18n.t('sync.progress.starting'),
+        },
+        silent,
+      );
 
       const result = await this.withAutoLoginRetry(
         () => synkronusApi.syncObservations(includeAttachments, syncOptions),
@@ -281,17 +313,20 @@ export class SyncService {
         `observations sync done @ ${finalVersion} gen=${repoGenStorage} pendingAttachments=${pendingAttachments}`,
       );
 
-      this.updateProgress({
-        current: 1,
-        total: 1,
-        phase: 'push_observations',
-        details:
-          pendingAttachments > 0
-            ? i18n.t('sync.progress.attachmentsRemaining', {
-                count: pendingAttachments,
-              })
-            : i18n.t('sync.progress.complete'),
-      });
+      this.updateProgress(
+        {
+          current: 1,
+          total: 1,
+          phase: 'push_observations',
+          details:
+            pendingAttachments > 0
+              ? i18n.t('sync.progress.attachmentsRemaining', {
+                  count: pendingAttachments,
+                })
+              : i18n.t('sync.progress.complete'),
+        },
+        silent,
+      );
       await AsyncStorage.setItem('@last_seen_version', finalVersion.toString());
 
       const outcome: SyncOutcome =
@@ -303,7 +338,7 @@ export class SyncService {
             }
           : { kind: 'success', finalVersion };
 
-      this.applySyncOutcome(outcome);
+      this.applySyncOutcome(outcome, silent);
       await logger.breadcrumb('sync', 'end', {
         success: pendingAttachments === 0,
         counts: pendingAttachments,
@@ -314,7 +349,7 @@ export class SyncService {
     } catch (error) {
       if (isCancelledError(error)) {
         logger.info('sync', 'cancel observed, aborting');
-        this.applySyncOutcome({ kind: 'cancelled' });
+        this.applySyncOutcome({ kind: 'cancelled' }, silent);
         throw error;
       }
       logger.error(
@@ -322,17 +357,19 @@ export class SyncService {
         error instanceof Error ? error.message : 'Sync failed',
       );
       const errorMessage = getUserFacingSyncErrorMessage(error);
-      this.applySyncOutcome({ kind: 'failed', errorMessage });
+      this.applySyncOutcome({ kind: 'failed', errorMessage }, silent);
       throw error;
     } finally {
       this.isSyncing = false;
       this.canCancel = false;
       this.shouldCancel = false;
-      await notificationService.stopForegroundService();
+      if (!silent) {
+        await notificationService.stopForegroundService();
+      }
     }
   }
 
-  private applySyncOutcome(outcome: SyncOutcome): void {
+  private applySyncOutcome(outcome: SyncOutcome, silent: boolean): void {
     let status: string;
     let notificationOutcome: SyncNotificationOutcome;
 
@@ -364,18 +401,21 @@ export class SyncService {
     }
 
     this.updateStatus(status);
-    profileActivity
-      .run('Sync outcome notification', () =>
-        notificationService.showSyncComplete(notificationOutcome),
-      )
-      .catch(error =>
-        logger.warn(
-          'sync',
-          error instanceof Error
-            ? error.message
-            : 'Failed to show sync outcome notification',
-        ),
-      );
+
+    if (!silent) {
+      profileActivity
+        .run('Sync outcome notification', () =>
+          notificationService.showSyncComplete(notificationOutcome),
+        )
+        .catch(error =>
+          logger.warn(
+            'sync',
+            error instanceof Error
+              ? error.message
+              : 'Failed to show sync outcome notification',
+          ),
+        );
+    }
   }
 
   /**
diff --git a/formulus/src/services/__tests__/AutoSyncService.test.ts b/formulus/src/services/__tests__/AutoSyncService.test.ts
new file mode 100644
index 000000000..42eaae2f6
--- /dev/null
+++ b/formulus/src/services/__tests__/AutoSyncService.test.ts
@@ -0,0 +1,157 @@
+jest.mock(
+  '../../profiles/ProfileRuntime',
+  () => ({
+    getActiveProfile: jest.fn(() => ({ id: 'profile-a' })),
+  }),
+  { virtual: true },
+);
+
+jest.mock('../AutoSyncSettingsService', () => ({
+  loadAutoSyncSettings: jest.fn(),
+}));
+
+jest.mock('../SyncService', () => ({
+  syncService: {
+    getIsSyncing: jest.fn(),
+    syncObservations: jest.fn(),
+  },
+}));
+
+import { AppState, type AppStateStatus } from 'react-native';
+import { getActiveProfile } from '../../profiles/ProfileRuntime';
+import { loadAutoSyncSettings } from '../AutoSyncSettingsService';
+import { syncService } from '../SyncService';
+import { AutoSyncService } from '../AutoSyncService';
+
+describe('AutoSyncService', () => {
+  let appStateHandler: ((state: AppStateStatus) => void) | undefined;
+  let service: AutoSyncService;
+
+  const flushPromises = async (): Promise<void> => {
+    await Promise.resolve();
+    await Promise.resolve();
+  };
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.clearAllMocks();
+
+    appStateHandler = undefined;
+
+    Object.defineProperty(AppState, 'currentState', {
+      configurable: true,
+      value: 'active',
+    });
+
+    Object.defineProperty(AppState, 'addEventListener', {
+      configurable: true,
+      value: jest.fn(
+        (_event: string, handler: (state: AppStateStatus) => void) => {
+          appStateHandler = handler;
+
+          return {
+            remove: jest.fn(),
+          };
+        },
+      ),
+    });
+
+    jest
+      .mocked(getActiveProfile)
+      .mockReturnValue({ id: 'profile-a' } as ReturnType<
+        typeof getActiveProfile
+      >);
+
+    jest.mocked(loadAutoSyncSettings).mockResolvedValue({
+      enabled: true,
+      intervalMs: 5 * 60 * 1000,
+    });
+
+    jest.mocked(syncService.getIsSyncing).mockReturnValue(false);
+    jest.mocked(syncService.syncObservations).mockResolvedValue(1);
+
+    service = AutoSyncService.getInstance();
+    service.stop();
+  });
+
+  afterEach(() => {
+    service.stop();
+    jest.useRealTimers();
+  });
+
+  const startActiveService = async (): Promise<void> => {
+    service.start();
+
+    // Drive the singleton through its public AppState lifecycle so every
+    // test begins from a known foreground state.
+    appStateHandler?.('active');
+
+    await flushPromises();
+  };
+
+  test('does not sync immediately when started', async () => {
+    await startActiveService();
+
+    expect(syncService.syncObservations).not.toHaveBeenCalled();
+  });
+
+  test('runs a silent sync after the configured interval', async () => {
+    await startActiveService();
+
+    await jest.advanceTimersByTimeAsync(5 * 60 * 1000);
+
+    expect(syncService.syncObservations).toHaveBeenCalledWith({
+      includeAttachments: false,
+      silent: true,
+    });
+  });
+
+  test('does not auto-sync while the app is backgrounded', async () => {
+    await startActiveService();
+
+    appStateHandler?.('background');
+
+    await jest.advanceTimersByTimeAsync(5 * 60 * 1000);
+
+    expect(syncService.syncObservations).not.toHaveBeenCalled();
+  });
+
+  test('waits for a fresh interval after returning to foreground', async () => {
+    await startActiveService();
+
+    appStateHandler?.('background');
+    appStateHandler?.('active');
+
+    await flushPromises();
+
+    expect(syncService.syncObservations).not.toHaveBeenCalled();
+
+    await jest.advanceTimersByTimeAsync(5 * 60 * 1000);
+
+    expect(syncService.syncObservations).toHaveBeenCalledTimes(1);
+  });
+
+  test('skips a scheduled tick when another sync is running', async () => {
+    jest.mocked(syncService.getIsSyncing).mockReturnValue(true);
+
+    await startActiveService();
+
+    await jest.advanceTimersByTimeAsync(5 * 60 * 1000);
+
+    expect(syncService.syncObservations).not.toHaveBeenCalled();
+  });
+
+  test('does not sync the old profile after the active profile changes', async () => {
+    await startActiveService();
+
+    jest
+      .mocked(getActiveProfile)
+      .mockReturnValue({ id: 'profile-b' } as ReturnType<
+        typeof getActiveProfile
+      >);
+
+    await jest.advanceTimersByTimeAsync(5 * 60 * 1000);
+
+    expect(syncService.syncObservations).not.toHaveBeenCalled();
+  });
+});
diff --git a/formulus/src/services/__tests__/AutoSyncSettingsService.test.ts b/formulus/src/services/__tests__/AutoSyncSettingsService.test.ts
new file mode 100644
index 000000000..94e7ef90d
--- /dev/null
+++ b/formulus/src/services/__tests__/AutoSyncSettingsService.test.ts
@@ -0,0 +1,98 @@
+import ProfileStorage from '../../profiles/ProfileStorage';
+import {
+  AUTO_SYNC_INTERVALS,
+  DEFAULT_AUTO_SYNC_SETTINGS,
+  loadAutoSyncSettings,
+  saveAutoSyncSettings,
+} from '../AutoSyncSettingsService';
+
+jest.mock('../../profiles/ProfileStorage', () => ({
+  __esModule: true,
+  default: {
+    getItem: jest.fn(),
+    setItem: jest.fn(),
+  },
+}));
+
+const mockedProfileStorage = ProfileStorage as jest.Mocked<
+  typeof ProfileStorage
+>;
+
+describe('AutoSyncSettingsService', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('defaults to disabled with a five minute interval', async () => {
+    mockedProfileStorage.getItem.mockResolvedValue(null);
+
+    await expect(loadAutoSyncSettings()).resolves.toEqual({
+      enabled: false,
+      intervalMs: 5 * 60_000,
+    });
+  });
+
+  test('supports the configured auto-sync intervals', () => {
+    expect(AUTO_SYNC_INTERVALS).toEqual([
+      30_000,
+      2 * 60_000,
+      5 * 60_000,
+      15 * 60_000,
+      60 * 60_000,
+      24 * 60 * 60_000,
+    ]);
+  });
+
+  test('loads saved settings', async () => {
+    mockedProfileStorage.getItem.mockResolvedValue(
+      JSON.stringify({
+        enabled: true,
+        intervalMs: 2 * 60_000,
+      }),
+    );
+
+    await expect(loadAutoSyncSettings()).resolves.toEqual({
+      enabled: true,
+      intervalMs: 2 * 60_000,
+    });
+  });
+
+  test('falls back to defaults for malformed settings', async () => {
+    mockedProfileStorage.getItem.mockResolvedValue('not-json');
+
+    await expect(loadAutoSyncSettings()).resolves.toEqual(
+      DEFAULT_AUTO_SYNC_SETTINGS,
+    );
+  });
+
+  test('falls back to the default interval for unsupported values', async () => {
+    mockedProfileStorage.getItem.mockResolvedValue(
+      JSON.stringify({
+        enabled: true,
+        intervalMs: 1234,
+      }),
+    );
+
+    await expect(loadAutoSyncSettings()).resolves.toEqual({
+      enabled: true,
+      intervalMs: 5 * 60_000,
+    });
+  });
+
+  test('saves settings through profile-scoped storage', async () => {
+    mockedProfileStorage.setItem.mockResolvedValue();
+
+    await saveAutoSyncSettings({
+      enabled: true,
+      intervalMs: 15 * 60_000,
+    });
+
+    expect(mockedProfileStorage.setItem).toHaveBeenCalledWith(
+      '@auto_sync_settings',
+      JSON.stringify({
+        enabled: true,
+        intervalMs: 15 * 60_000,
+      }),
+    );
+  });
+});
diff --git a/formulus/src/services/__tests__/SyncService.autoLogin.test.ts b/formulus/src/services/__tests__/SyncService.autoLogin.test.ts
index 5e33a9f70..99adb9d78 100644
--- a/formulus/src/services/__tests__/SyncService.autoLogin.test.ts
+++ b/formulus/src/services/__tests__/SyncService.autoLogin.test.ts
@@ -235,6 +235,70 @@ describe('SyncService - Auto-Login Integration', () => {
     expect(profileActivity.isBusy()).toBe(false);
   });
 
+  describe('silent sync', () => {
+    test('syncs observations without foreground or completion notifications', async () => {
+      (isUnauthorizedError as jest.Mock).mockReturnValue(false);
+      (synkronusApi.syncObservations as jest.Mock).mockResolvedValue({
+        version: 42,
+        pendingAttachmentDownloads: 0,
+        pendingAttachmentUploads: 0,
+      });
+
+      const result = await syncService.syncObservations({
+        includeAttachments: false,
+        silent: true,
+      });
+
+      expect(result).toBe(42);
+      expect(synkronusApi.syncObservations).toHaveBeenCalledTimes(1);
+
+      expect(
+        notificationService.clearAllSyncNotifications,
+      ).not.toHaveBeenCalled();
+      expect(notificationService.startForegroundService).not.toHaveBeenCalled();
+      expect(notificationService.showSyncProgress).not.toHaveBeenCalled();
+      expect(notificationService.showSyncComplete).not.toHaveBeenCalled();
+      expect(notificationService.stopForegroundService).not.toHaveBeenCalled();
+    });
+
+    test('keeps silent sync failures non-intrusive', async () => {
+      const error = new Error('Network unavailable');
+
+      (isUnauthorizedError as jest.Mock).mockReturnValue(false);
+      (synkronusApi.syncObservations as jest.Mock).mockRejectedValue(error);
+
+      await expect(
+        syncService.syncObservations({
+          includeAttachments: false,
+          silent: true,
+        }),
+      ).rejects.toThrow('Network unavailable');
+
+      expect(notificationService.showSyncProgress).not.toHaveBeenCalled();
+      expect(notificationService.showSyncComplete).not.toHaveBeenCalled();
+      expect(notificationService.startForegroundService).not.toHaveBeenCalled();
+      expect(notificationService.stopForegroundService).not.toHaveBeenCalled();
+    });
+
+    test('preserves existing notification behavior for manual sync', async () => {
+      (isUnauthorizedError as jest.Mock).mockReturnValue(false);
+      (synkronusApi.syncObservations as jest.Mock).mockResolvedValue({
+        version: 43,
+        pendingAttachmentDownloads: 0,
+        pendingAttachmentUploads: 0,
+      });
+
+      await expect(syncService.syncObservations(false)).resolves.toBe(43);
+
+      expect(notificationService.startForegroundService).toHaveBeenCalled();
+      expect(notificationService.showSyncProgress).toHaveBeenCalled();
+      expect(notificationService.showSyncComplete).toHaveBeenCalledWith({
+        kind: 'success',
+      });
+      expect(notificationService.stopForegroundService).toHaveBeenCalled();
+    });
+  });
+
   describe('withAutoLoginRetry - syncObservations', () => {
     test('should retry syncObservations after auto-login on 401 error', async () => {
       const mockUserInfo = {