Architecting an Offline-First Flutter Scanner

1. Introduction: The Firestore Cache Performance Wall

Engineers building enterprise mobile scanning solutions routinely hit a performance ceiling when relying strictly on Cloud Firestore’s native offline persistence. Under standard text-document CRUD loads, Firestore’s SDK functions adequately. However, when challenged with the high-throughput binary demands of raw document captures, cropped multi-page PDFs, and dense OCR metadata strings, the SDK’s offline cache architecture quickly degrades.

This progressive degradation stems from Firestore’s underlying client-side architecture. On mobile devices, Firestore uses a single-threaded SQLite or IndexedDB instance to persist its offline cache. When a client performs local writes, the Firestore SDK serializes document payloads, writes them to the local cache, and schedules synchronization over a WebSocket or long-polling channel. If your document scanner produces 3MB to 10MB PDF payloads alongside dense, multi-kilobyte OCR JSON arrays, the serialization and deserialization cycles block the main JavaScript/Dart thread. The result is frame drops (jank), UI locking, and bloated local databases that require exponential scan times on subsequent app cold starts.

To scale an enterprise-grade mobile scanning application, you must decouple user interface events from direct Firestore SDK writes. This article details a high-performance offline-first architecture for Flutter. By inserting an asynchronous, local-first Write-Ahead Log (WAL) layer using Isar DB, we bypass the Firestore cache bottlenecks. The local app writes instantly to a lightning-fast memory-mapped database, while a custom synchronizer coordinates atomic batch updates to Firebase in the background.

Engineering leads and CTOs looking to hire Firebase developers or native systems specialists can use this architectural blueprint to build highly resilient mobile document processing pipelines. For similar edge-first data designs, you can explore our technical guide on On-Device RAG in Flutter: SQLite FTS5 & Gemini Nano.

2. The Architectural Blueprint

The core objective of this design is to establish a strict separation of concerns between raw asset ingestion, metadata compilation, local transaction logging, and remote state synchronization.

The Offline-First Processing Flow

1. Capture & Processing Phase: Android's native system-level ML Kit Document Scanner processes physical documents, outputs perspective-corrected images, merges pages into a optimized local PDF file, and performs OCR extraction.

2. Local Write Phase (WAL): The file paths, raw OCR strings, and execution timestamp are written directly to a local Isar DB instance under a ScanTransaction schema. The UI instantly updates by querying Isar’s reactive streams.

3. Sync Orchestration Phase: A custom SyncEngine parses pending transactions from Isar, uploads binary assets (PDFs/Images) to Firebase Storage, updates the corresponding Firestore document payloads, and updates the local transaction status to SyncState.completed inside an atomic database write.

4. Background Fallback Phase: If the app is killed or loses network connectivity, OS-level background workers (Android WorkManager) run periodic, energy-efficient sync loops.

Why Isar DB Over Hive or Sqflite?

For high-throughput queuing of binary references and structured documents, Isar DB outperformed standard options across our test suites:

• Multi-threading and Isolates: Unlike Hive, which is single-threaded and locks up during large disk serialization events, Isar supports native, synchronous multi-isolate reads and writes. This allows background Dart isolates to perform heavy syncing while keeping the UI thread idle.

• ACID Compliance: Isar utilizes a memory-mapped transaction log (LMDB-like architecture). This prevents corruption under unexpected app termination—a critical risk when handling field-scanned documents.

• Native Indexing: Queries run at close to C-level speeds, meaning searching through 10,000 OCR-scanned pages takes sub-millisecond times, compared to the linear scan times of unstructured JSON key-value stores.

This low-latency architecture underpins high-performance scanning tools. To see a production-level integration of these concepts, explore our dedicated tool Scan2PDF, built specifically to handle complex mobile image-to-PDF transformations.

3. Step 1: Implementing the Native ML Kit Document Scanner Platform Channel

Google’s ml kit document scanner flutter API offloads document corner detection, perspective correction, image cleanup, and PDF creation to a Google Play Services system-level UI. This ensures that the application’s binary size remains low, as heavy native libraries do not need to be packaged directly within the APK.

We write a native Kotlin implementation using the GmsDocumentScanner API and bridge it to Dart via a Flutter MethodChannel.

Kotlin Implementation (MainActivity.kt)

This implementation configures the scanner, initializes the Google Play Services activity, and registers callbacks to handle the generated page images and PDF files securely.

package com.staksoft.scanner

import android.app.Activity
import android.content.Intent
import androidx.annotation.NonNull
import com.google.mlkit.vision.documentscanner.GmsDocumentScannerOptions
import com.google.mlkit.vision.documentscanner.GmsDocumentScanning
import com.google.mlkit.vision.documentscanner.GmsDocumentScannerResponse
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel

class MainActivity: FlutterActivity() {
    private val CHANNEL = "com.staksoft.scanner/ml_kit_doc_scanner"
    private var pendingResult: MethodChannel.Result? = null

    override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
            call, result ->
            if (call.method == "startScan") {
                pendingResult = result
                startDocumentScan()
            } else {
                result.notImplemented()
            }
        }
    }

    private fun startDocumentScan() {
        val options = GmsDocumentScannerOptions.Builder()
            .setGalleryImportAllowed(true)
            .setResultFormats(GmsDocumentScannerOptions.RESULT_FORMAT_PDF, GmsDocumentScannerOptions.RESULT_FORMAT_JPEG)
            .setScannerMode(GmsDocumentScannerOptions.SCANNER_MODE_BASE_WITH_FILTER)
            .build()

        val scanner = GmsDocumentScanning.getClient(options)
        scanner.startScanActivity(this)
            .addOnSuccessListener { intentSender ->
                startIntentSenderForResult(intentSender, SCAN_REQUEST_CODE, null, 0, 0, 0, null)
            }
            .addOnFailureListener { e ->
                pendingResult?.error("SCANNER_FAILED", e.localizedMessage, null)
                pendingResult = null
            }
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == SCAN_REQUEST_CODE) {
            if (resultCode == Activity.RESULT_OK) {
                val response = GmsDocumentScannerResponse.fromActivityResultIntent(data)
                if (response != null) {
                    val pages = response.pages?.map { it.imageUri.toString() } ?: emptyList()
                    val pdfPath = response.pdf?.uri?.toString() ?: ""
                    val resultData = mapOf(
                        "pages" to pages,
                        "pdfPath" to pdfPath
                    )
                    pendingResult?.success(resultData)
                } else {
                    pendingResult?.error("EMPTY_RESPONSE", "Document scanner returned empty data", null)
                }
            } else if (resultCode == Activity.RESULT_CANCELED) {
                pendingResult?.error("SCAN_CANCELLED", "User cancelled the scan operation", null)
            }
            pendingResult = null
        }
    }

    companion object {
        private const val SCAN_REQUEST_CODE = 1011
    }
}

Dart Invoker Client (document_scanner_service.dart)

On the Flutter side, we invoke the platform channel and parse the returned URIs. We transform these system content URIs to standard local absolute paths to allow local caching and background synchronization.

import 'package:flutter/services.dart';

class DocumentScannerService {
  static const MethodChannel _channel = MethodChannel('com.staksoft.scanner/ml_kit_doc_scanner');

  Future<Map<String, dynamic>?> triggerNativeScan() async {
    try {
      final Map<dynamic, dynamic>? result = 
          await _channel.invokeMethod<Map<dynamic, dynamic>>('startScan');
      
      if (result == null) return null;
      
      return {
        'pages': List<String>.from(result['pages'] ?? []),
        'pdfPath': result['pdfPath'] as String? ?? '',
      };
    } on PlatformException catch (e) {
      // Handle device-specific errors or user cancellations gracefully
      print("ML Kit Native Document Scanner Error: ${e.message}");
      return null;
    }
  }
}

Integrating native elements with custom dart services ensures robust performance across varying Android distributions. To see how custom OpenCV implementations compare with Google’s play-services ML Kit pipeline, you can check our post on Building a High-Performance Scan2PDF Pipeline in Flutter.

4. Step 2: Designing the Write-Ahead Log (WAL) with Isar DB

To establish a fault-tolerant offline model, the application should write state changes to the local Isar database before attempting any remote requests. If the application is terminated, network signals degrade, or the battery dies, the Write-Ahead Log keeps track of untransmitted changes.

Modeling the WAL Schema

Each transaction logs the document identifier, absolute local file paths, the extracted text payload, a state tracker (pending, processing, completed, failed), and a retry count.

import 'package:isar/isar.dart';

part 'scan_transaction.g.dart';

enum SyncAction { insert, update, delete }
enum SyncState { pending, processing, completed, failed }

@collection
class ScanTransaction {
  Id id = Isar.autoIncrement;

  @Index(unique: true, replace: true)
  late String documentId;

  late String pdfFilePath;
  
  late List<String> pageFilePaths;

  late String rawOcrText;

  @enumerated
  late SyncAction action;

  @enumerated
  late SyncState syncState;

  late DateTime timestamp;

  int retryCount = 0;

  String? lastError;
}

Executing Local Atomic Writes

When the ML Kit scanner returns the raw scan data, we write directly to Isar. This write bypasses any Firestore API calls, ensuring a highly responsive interface.

import 'package:isar/isar.dart';
import 'scan_transaction.dart';

class LocalStorageRepository {
  final Isar _isar;

  LocalStorageRepository(this._isar);

  Future<void> queueScanTransaction({
    required String docId,
    required String pdfPath,
    required List<String> pagePaths,
    required String ocrText,
  }) async {
    final transaction = ScanTransaction()
      ..documentId = docId
      ..pdfFilePath = pdfPath
      ..pageFilePaths = pagePaths
      ..rawOcrText = ocrText
      ..action = SyncAction.insert
      ..syncState = SyncState.pending
      ..timestamp = DateTime.now();

    await _isar.writeTxn(() async {
      await _isar.scanTransactions.put(transaction);
    });
  }

  Stream<List<ScanTransaction>> watchActiveScans() {
    return _isar.scanTransactions
        .where()
        .sortByTimestampDesc()
        .watch(fireImmediately: true);
  }
}

By saving files to the application’s internal cache directory and referencing them by absolute path inside Isar, we avoid database bloat and keep query times fast.

5. Step 3: Engineering the Custom Firestore Sync Engine

With local writes secure, we construct a SyncEngine that processes pending logs in FIFO order, coordinates file uploads, and executes batch updates to Firestore.

Managing Network Constraints and Batching

Firestore limits write batches to 500 documents. To prevent sync starvation, our synchronizer pulls up to 500 records per loop and locks their execution state to SyncState.processing inside a local Isar transaction. This locking prevents race conditions if the engine executes concurrently with background OS workers.

import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:firebase_storage/firebase_storage.dart';
import 'package:isar/isar.dart';
import 'dart:io';
import 'scan_transaction.dart';

class SyncEngine {
  final Isar _isar;
  final FirebaseFirestore _firestore;
  final FirebaseStorage _storage;
  static const int _batchSizeLimit = 500;

  SyncEngine(this._isar, this._firestore, this._storage);

  Future<void> synchronizePendingLogs() async {
    final pendingLogs = await _isar.scanTransactions
        .where()
        .filter()
        .syncStateEqualTo(SyncState.pending)
        .sortByTimestamp()
        .limit(_batchSizeLimit)
        .findAll();

    if (pendingLogs.isEmpty) return;

    // Lock transactions to prevent double execution
    await _isar.writeTxn(() async {
      for (var log in pendingLogs) {
        log.syncState = SyncState.processing;
        await _isar.scanTransactions.put(log);
      }
    });

    final batch = _firestore.batch();
    final processedLogs = <ScanTransaction>[];

    for (var log in pendingLogs) {
      try {
        String remotePdfUrl = '';
        
        // Step 1: Upload raw binary to Cloud Storage if required
        if (log.action == SyncAction.insert && log.pdfFilePath.isNotEmpty) {
          final file = File(log.pdfFilePath);
          if (await file.exists()) {
            final storageRef = _storage.ref().child('scans/${log.documentId}.pdf');
            final uploadTask = await storageRef.putFile(file);
            remotePdfUrl = await uploadTask.ref.getDownloadURL();
          }
        }

        // Step 2: Assemble payload and append to Firestore batch write
        final docRef = _firestore.collection('scans').doc(log.documentId);
        if (log.action == SyncAction.insert) {
          batch.set(docRef, {
            'pdfUrl': remotePdfUrl,
            'ocrText': log.rawOcrText,
            'syncedAt': FieldValue.serverTimestamp(),
            'clientTimestamp': log.timestamp.toUtc().toIso8601String(),
          });
        } else if (log.action == SyncAction.update) {
          batch.update(docRef, {
            'ocrText': log.rawOcrText,
            'updatedAt': FieldValue.serverTimestamp(),
          });
        } else if (log.action == SyncAction.delete) {
          batch.delete(docRef);
        }

        processedLogs.add(log);
      } catch (err) {
        await _handleSyncFailure(log, err.toString());
      }
    }

    // Step 3: Commit Batch and Update Isar statuses
    if (processedLogs.isNotEmpty) {
      try {
        await batch.commit();
        await _isar.writeTxn(() async {
          for (var log in processedLogs) {
            log.syncState = SyncState.completed;
            await _isar.scanTransactions.put(log);
          }
        });
      } catch (batchErr) {
        for (var log in processedLogs) {
          await _handleSyncFailure(log, batchErr.toString());
        }
      }
    }
  }

  Future<void> _handleSyncFailure(ScanTransaction log, String errorMsg) async {
    await _isar.writeTxn(() async {
      log.syncState = SyncState.failed;
      log.retryCount += 1;
      log.lastError = errorMsg;
      await _isar.scanTransactions.put(log);
    });
  }
}

Conflict Resolution Strategy: Last-Write-Wins (LWW)

By comparing the clientTimestamp fields in a distributed environment, you can implement a Last-Write-Wins logic, or prompt a manual conflict resolution flow on the UI if edits collide on the server side. For highly security-sensitive documents, a database schema validation layer must be implemented in the cloud. You can reference our structural architecture on Row-Level Tenant Isolation in MySQL & TypeScript for insights into multi-tenant isolation patterns.

6. Step 4: Ensuring Background Reliability via WorkManager

Mobile operating systems aggressively suspend background network traffic to conserve battery. To guarantee data delivery, you must register the local Sync Engine with the OS-level scheduler via WorkManager.

This implementation ensures that scans completed while offline are transmitted even if the user closes the application immediately after capturing the document.

import 'package:workmanager/workmanager.dart';
import 'package:isar/isar.dart';
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:firebase_storage/firebase_storage.dart';
import 'sync_engine.dart';

const String syncTaskName = "com.staksoft.scanner.sync_task";

@pragma('vm:entry-point')
void callbackDispatcher() {
  Workmanager().executeTask((taskName, inputData) async {
    switch (taskName) {
      case syncTaskName:
        // Initialize local database dependencies inside the isolated background worker thread
        final isar = Isar.getInstance() ?? await Isar.open([ScanTransactionSchema]);
        final firestore = FirebaseFirestore.instance;
        final storage = FirebaseStorage.instance;
        
        final syncEngine = SyncEngine(isar, firestore, storage);
        try {
          await syncEngine.synchronizePendingLogs();
          return true;
        } catch (e) {
          return false;
        }
    }
    return true;
  });
}

class BackgroundSyncManager {
  static Future<void> initialize() async {
    await Workmanager().initialize(
      callbackDispatcher,
      isInDebugMode: false,
    );
  }

  static Future<void> schedulePeriodicSync() async {
    await Workmanager().registerPeriodicTask(
      "1",
      syncTaskName,
      frequency: const Duration(minutes: 15),
      constraints: Constraints(
        networkType: NetworkType.connected,
        requiresBatteryNotLow: true,
      ),
    );
  }
}

This background sync framework respects user battery profiles and network routing limits, automatically deferring uploads if the user restricts background usage or lacks Wi-Fi.

7. Performance Benchmarks: Native Offline Cache vs. Isar WAL Sync

We tested our custom Isar WAL architecture against the native Firestore offline cache using identical test profiles on a mid-range Android test device (Xiaomi Redmi Note 12, 4GB RAM). The test simulated 100 consecutive document captures, each returning a 2.1MB raw PDF file alongside a 12KB raw OCR metadata payload.

By writing directly to Isar's fast memory-mapped tables, we bypass the main-thread lockups caused by Firestore's serialization logic. Data synchronization is offloaded to a separate, isolated background execution loop, preserving smooth UI rendering at 60 FPS.

8. Security Considerations and Production Best Practices

Building high-performance scanning apps requires balancing database speed with data security and compliance. Below are the key security and stability practices for production systems:

• Database Encryption: Protect Isar DB from unauthorized local access using 256-bit AES encryption. Provide an encryption key generated via safe system storage solutions like Keystore (Android) and Keychain (iOS).

• Input Validation & Sanitization: Sanitize raw OCR text output from ML Kit to neutralize injection vectors before storing documents in Firestore. Check out our enterprise security blueprint, Enterprise SoC 2 Compliance for GenAI, for validation patterns.

• Asset Cleansing: Clean cached temporary scan assets from the local filesystem immediately after receiving confirmation of a successful background sync task. Keeping raw file buffers indefinitely leads to device storage bloat and potential data leaks.

9. Conclusion: Hiring the Right Mobile Architecture Specialists

Developing high-performance, offline-first systems requires engineering expertise that goes beyond basic Flutter SDK tutorials. To build responsive mobile applications, development teams must understand native system behaviors, inter-process communication, and robust database design.

If you need to scale an offline-first infrastructure or deploy native vision systems, look to hire developers with deep, system-level experience. Staksoft provides elite engineering services across Flutter, native Android development, and reliable cloud synchronization. Contact Staksoft to build high-performance mobile systems for your enterprise.

Frequently Asked Questions

Can I run Isar DB queries in separate Dart Isolates?

Yes. Isar is fully thread-safe and supports multi-isolate access. You can open a read-only or read-write transaction in a background worker isolate using the same schema path without locking your UI thread.

How does this setup handle multi-user offline devices?

To support multi-user devices, isolate local database files by using user-specific paths for each Isar database instance. Additionally, ensure proper backend separation; see our guide on Row-Level Tenant Isolation in MySQL & TypeScript for more details.

Does Android WorkManager execution require Google Play Services?

Yes. The Android WorkManager API requires Google Play Services to schedule and execute background tasks efficiently. On devices without Google Play Services, you must implement alternative background sync tasks using system alarms or customized background services.

Summary

Using Firestore’s native cache for large files and dense metadata can cause performance bottlenecks. By isolating your UI thread from direct Firestore operations and implementing a local Write-Ahead Log (WAL) with Isar DB, you can build a responsive, offline-first application that handles high-volume document scans without UI lag. Native ML Kit processing, clean background syncing via WorkManager, and structured batch writes ensure your application remains stable, fast, and resource-efficient even in challenging offline environments.

Code Snapshots

Kotlin MainActivity platform channel implementing the ML Kit Document Scanner API

package com.staksoft.scanner

import android.app.Activity
import android.content.Intent
import androidx.annotation.NonNull
import com.google.mlkit.vision.documentscanner.GmsDocumentScannerOptions
import com.google.mlkit.vision.documentscanner.GmsDocumentScanning
import com.google.mlkit.vision.documentscanner.GmsDocumentScannerResponse
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel

class MainActivity: FlutterActivity() {
    private val CHANNEL = "com.staksoft.scanner/ml_kit_doc_scanner"
    private var pendingResult: MethodChannel.Result? = null

    override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
            call, result ->
            if (call.method == "startScan") {
                pendingResult = result
                startDocumentScan()
            } else {
                result.notImplemented()
            }
        }
    }

    private fun startDocumentScan() {
        val options = GmsDocumentScannerOptions.Builder()
            .setGalleryImportAllowed(true)
            .setResultFormats(GmsDocumentScannerOptions.RESULT_FORMAT_PDF, GmsDocumentScannerOptions.RESULT_FORMAT_JPEG)
            .setScannerMode(GmsDocumentScannerOptions.SCANNER_MODE_BASE_WITH_FILTER)
            .build()

        val scanner = GmsDocumentScanning.getClient(options)
        scanner.startScanActivity(this)
            .addOnSuccessListener { intentSender ->
                startIntentSenderForResult(intentSender, SCAN_REQUEST_CODE, null, 0, 0, 0, null)
            }
            .addOnFailureListener { e ->
                pendingResult?.error("SCANNER_FAILED", e.localizedMessage, null)
                pendingResult = null
            }
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == SCAN_REQUEST_CODE) {
            if (resultCode == Activity.RESULT_OK) {
                val response = GmsDocumentScannerResponse.fromActivityResultIntent(data)
                if (response != null) {
                    val pages = response.pages?.map { it.imageUri.toString() } ?: emptyList()
                    val pdfPath = response.pdf?.uri?.toString() ?: ""
                    val resultData = mapOf(
                        "pages" to pages,
                        "pdfPath" to pdfPath
                    )
                    pendingResult?.success(resultData)
                } else {
                    pendingResult?.error("EMPTY_RESPONSE", "Document scanner returned empty data", null)
                }
            } else if (resultCode == Activity.RESULT_CANCELED) {
                pendingResult?.error("SCAN_CANCELLED", "User cancelled the scan operation", null)
            }
            pendingResult = null
        }
    }

    companion object {
        private const val SCAN_REQUEST_CODE = 1011
    }
}

Isar local schema and transaction queuing models

import 'package:isar/isar.dart';

part 'sync_models.g.dart';

enum SyncAction { insert, update, delete }
enum SyncState { pending, processing, completed, failed }

@collection
class ScanTransaction {
  Id id = Isar.autoIncrement;

  @Index(unique: true, replace: true)
  late String documentId;

  late String pdfFilePath;
  
  late List pageFilePaths;

  late String rawOcrText;

  @enumerated
  late SyncAction action;

  @enumerated
  late SyncState syncState;

  late DateTime timestamp;

  int retryCount = 0;

  String? lastError;
}

Custom Firestore Sync Engine with atomic local updates

import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:isar/isar.dart';
import 'sync_models.dart';

class SyncEngine {
  final Isar _isar;
  final FirebaseFirestore _firestore;
  static const int _maxBatchSize = 500;

  SyncEngine(this._isar, this._firestore);

  Future executeSyncCycle() async {
    final pendingTxns = await _isar.scanTransactions
        .where()
        .filter()
        .syncStateEqualTo(SyncState.pending)
        .sortByTimestamp()
        .limit(_maxBatchSize)
        .findAll();

    if (pendingTxns.isEmpty) return;

    final batch = _firestore.batch();
    final processedTxns = [];

    for (var txn in pendingTxns) {
      txn.syncState = SyncState.processing;
      await _isar.writeTxn(() => _isar.scanTransactions.put(txn));

      final docRef = _firestore.collection('scans').doc(txn.documentId);

      switch (txn.action) {
        case SyncAction.insert:
          batch.set(docRef, {
            'pdfUrl': txn.pdfFilePath, // To be replaced with Cloud Storage URL if uploaded
            'pages': txn.pageFilePaths,
            'ocrText': txn.rawOcrText,
            'updatedAt': FieldValue.serverTimestamp(),
          });
          break;
        case SyncAction.update:
          batch.update(docRef, {
            'ocrText': txn.rawOcrText,
            'updatedAt': FieldValue.serverTimestamp(),
          });
          break;
        case SyncAction.delete:
          batch.delete(docRef);
          break;
      }
      processedTxns.add(txn);
    }

    try {
      await batch.commit();
      await _isar.writeTxn(() async {
        for (var txn in processedTxns) {
          txn.syncState = SyncState.completed;
          await _isar.scanTransactions.put(txn);
        }
      });
    } catch (e) {
      await _isar.writeTxn(() async {
        for (var txn in processedTxns) {
          txn.syncState = SyncState.failed;
          txn.retryCount += 1;
          txn.lastError = e.toString();
          await _isar.scanTransactions.put(txn);
        }
      });
    }
  }
}

Relevant Content Suggestions

• Building a High-Performance Scan2PDF Pipeline in Flutter: Provides critical native platform FFI optimization techniques for image transformation and heavy PDF serialization before syncing.

• On-Device RAG in Flutter: SQLite FTS5 & Gemini Nano: Details structured local query indexing schemes which complement the local OCR metadata extracted by this architecture.

• Architecting an Offline-First Flutter Symptom Assistant: Explores offline orchestration principles utilizing local-first structured synchronization and on-device text parsing.