DEV Community: Karol Burdziński

Software development in the AI era - is vibe coding our future?

Karol Burdziński — Fri, 15 May 2026 14:46:58 +0000

Originally posted on https://proofpocket.com/blog/software-dev-in-ai-era

When I was building the first version of Proof Pocket, I wrote every line myself. Not because I had to, but because I needed to actually understand the domain — encryption, offline storage, what it means for a user to trust an app with sensitive documents. That understanding would have been much harder to gain if I had just prompted my way through it.

I think about that a lot when I see how AI-driven development is being sold right now.

We're moving complexity, not reducing it

A lot of AI-driven software development feels heavily influenced by marketing. We are being pushed toward vibe coding and faster delivery. Everyone keeps saying we will be left behind if we do not adopt it now. The promise is attractive: build more, ship faster, reduce the manual work.

But AI-generated results are often inconsistent and non-deterministic. Code review has always been one of the harder parts of software development, and now we are getting even more code to review. In some cases, we are not reducing complexity. We are just moving it somewhere else.

I also think real product understanding will become a serious problem. Developers usually understand the product better when they actually build parts of it themselves. If most of the implementation is delegated to AI, it becomes easier to lose context. And without context, it is much harder to make good technical and product decisions.

Code was rarely the bottleneck

This is subjective, but in many projects I have worked on, writing code was not always the thing that slowed us down the most.

Very often, the real blockers were decisions, unexpected pivots, unclear requirements, and changing direction in the middle of the work. Many times, I deleted my own code simply because the requirements changed.

In many teams, not enough attention is given to business analysis, diagrams, process descriptions, and proper planning before the coding starts. Decision-making is crucial and hard, and it is the part that gets skipped.

This does not apply to every case. Startups are different. When you are doing quick experiments, validating ideas, or building an MVP, speed matters a lot. But I would separate those situations from larger, more mature projects.

We need different processes, not one universal fix

I do not think there will be one perfect process for AI-assisted development. We probably need several different ways of building products, depending on the size, risk, and maturity of the project.

It is much easier to go into "YOLO mode" for a small product or startup. But for a big company with multiple products, especially critical ones like financial or medical systems, that approach is simply not acceptable.

Even before AI, I felt that being too attached to Scrum could become a rabbit hole. Imagine a small startup product estimated for two or three months of work. Having all the usual meetings, developing every tiny task independently, and then testing each one manually can waste a lot of time.

For this kind of project, I would rather divide the product into main workflows. Instead of treating every small part of the user account area as a separate delivery, I would group the whole user account and profile flow together — from account creation to filling in and editing profile data.

This bigger workflow can still be divided into smaller subtasks for easier code review. But I would not send every tiny part to QA separately. I would rather deliver the whole workflow, let QA test it manually as one complete section, gather all bugs, report them together, and then iterate.

With this approach, you can divide the app into a few real use cases and deliver them one after another. This makes even more sense for a startup or MVP, where the product should usually do one thing well instead of trying to become a super app from the beginning.

Someone could say that QA will have a lot to check at the end. But I think it is often easier to focus on a complete section of the app, write proper test cases for it, and test the whole flow without constantly switching between unrelated tasks and meetings.

This is also how Proof Pocket was handled. The first version was just simple onboarding and document encryption. No polished UI, no backups, no peer-to-peer transfers, no categories. It was supposed to address one simple problem: I have a confidential document on my phone, I want to keep it safely encrypted, and I want easy offline access to it.

But what about bigger projects?

Core domain still needs a human

I think the main domain should still be handled by software developers, with AI acting as an assistant. The code should be well known and understood by the developers, especially if they are expected to participate in decision-making meetings and understand the real business behind the product.

A good analogy is Domain-Driven Design. DDD teaches us to describe the main domain and subdomains carefully. Not every part of the system has the same importance. Some parts are core to the business, while others are just supporting or generic functionality.

This is where AI can be very useful. We can use AI to generate boilerplate, implement non-critical parts, help find bugs, audit code, or build features where deep business knowledge is not required.

For example, I do not always need to know every detail of how a table or view is rendered. But I do need to know what data should be presented, why it matters, and how it affects the user or the business process.

But for the core domain, I would be very careful. If the most important part of the business logic is generated without proper understanding, the team may move fast at the beginning and pay for it later.

Maintenance vs new features

AI is quite good when the task is to add another module, another layer, or another isolated feature. But reality is often more complicated than that.

Many legacy projects contain hard dependencies, hidden assumptions, and years of workarounds. New bugs can easily be introduced when existing code is changed. Sometimes the code looks strange only because the historical context is missing. Without that context, AI may "fix" something that was actually protecting the system from another problem.

From my experience, letting AI maintain a large legacy codebase is a no-go. AI can be very helpful when finding the source of an issue — reading stack traces, analyzing logs, pointing out suspicious places in the code. But when it tries to fix the issue automatically, it often introduces new problems.

We can build self-healing loops, automation, extra tests, and verification pipelines. But in most cases, the effort is not worth it.

For maintenance, I prefer to use AI in assisted mode. Let it help with debugging, finding the issue, deciphering native stack traces, and pointing out possible causes. But the actual bug fix should be done carefully by a human.

For new features, especially in a project with a good modular architecture, we can give AI a bit more freedom. If the boundaries are clear and the codebase has a proper test harness, AI can be very effective while still keeping the code reasonably clean.

Testing and AI

One thing I observe now is that when it becomes easy to add tons of tests with AI, people just do it.

At first, this sounds great. More tests, better coverage, fewer bugs. But in practice, many of those tests are useless AI slop that only extends the CI pipeline without giving much real confidence.

On the other hand, AI makes it much easier to add missing tests for parts of the system that we never had time to cover before. That is a real benefit.

Please do not flood your project with useless tests just because AI wants 100% coverage or because it can generate hundreds of test cases in a few seconds. Balance matters.

Tests should protect real behavior. They should document important assumptions. They should make refactoring safer. They should not exist only to satisfy a coverage number.

Where does that leave us?

I wonder what the future of software development will look like. I genuinely do not know.

AI will definitely change the way we build software. It already has. But I do not think the future is just about replacing developers with prompts.

Developers will still need to understand the product, the business domain, the architecture, and the trade-offs. AI will help us move faster, automate boring work, and explore solutions more quickly. The gap between what you can build and what you actually understand — that is where things will go wrong.

But the responsibility for the product will still stay with humans.

At least, I hope so.

The Developer's Guide to Actually Private Apps: No Cloud, No Analytics, No Tracking

Karol Burdziński — Sun, 28 Dec 2025 12:16:47 +0000

The Developer's Guide to Actually Private Apps: No Cloud, No Analytics, No Tracking

How to build truly private mobile apps using Flutter — with practical patterns, code examples, and architectural decisions that work on both iOS and Android

TL;DR: This guide walks through building truly private mobile apps using offline-first architecture with Flutter/Dart, discussing encryption, storage, permissions, and the tradeoffs between privacy and convenience.

The Privacy Problem in Modern App Development

Let's be honest: most of us are building apps that leak user data.

Not maliciously — usually through third-party packages, analytics tools, crash reporters, and cloud services we integrate without thinking twice.

Here's a typical "secure" app stack:

User Data
  ↓
App Logic
  ↓
├─ Firebase Analytics
├─ Crashlytics
├─ Cloud Storage SDK
├─ Authentication Service
└─ Ad Network SDK
  ↓
[Multiple Third-Party Servers]

Each integration point is a potential data leak. Each package has its own privacy policy. Each server is a breach waiting to happen.

What if we just... didn't do any of that?

The Offline-First Philosophy

Offline-first doesn't mean "works offline as a fallback." It means:

The app functions completely without network access, and network features (if any) are optional, explicit, and user-controlled.

For truly private apps, this principle becomes even stricter:

No network access, period. Everything stays on the device.

Why This Matters

If your app doesn't use the network:

No data can leak to third parties
No servers to breach
No privacy policy complications
No GDPR/CCPA compliance issues (for the app itself)
Users have complete control

The tradeoff? You lose:

Cloud sync
Cross-device access
Analytics insights
Remote feature flags
Push notifications
Crash reporting to your servers

For many apps, especially those handling sensitive data, this is a worthwhile tradeoff.

Building Blocks: Flutter/Dart Example

Let me walk through building a private vault app using Flutter. These patterns work on both iOS and Android with a single codebase.

1. Permissions: Request Only What's Necessary

DON'T:

<!-- AndroidManifest.xml with unnecessary permissions -->
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.READ_CONTACTS"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

<!-- iOS Info.plist with unnecessary permissions -->
<key>NSLocationWhenInUseUsageDescription</key>
<string>To provide better service</string>
<key>NSContactsUsageDescription</key>
<string>To help you share</string>

DO:

<!-- AndroidManifest.xml - minimal permissions -->
<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<!-- Note: Explicitly NO internet permission -->

<!-- iOS Info.plist - minimal permissions -->
<key>NSPhotoLibraryUsageDescription</key>
<string>To import photos into your encrypted vault</string>
<key>NSCameraUsageDescription</key>
<string>To capture documents for your vault</string>
<!-- That's it. No location, no contacts, no tracking. -->

Flutter pubspec.yaml - avoid network-dependent packages:

dependencies:
  flutter:
    sdk: flutter

  # Local storage & database
  sqflite: ^2.4.2
  path_provider: ^2.1.5
  shared_preferences: ^2.5.3

  # Security & encryption
  flutter_secure_storage: ^9.2.4
  biometric_storage: ^5.0.1
  fastcrypt: ^1.0.0  # Fast ChaCha encryption
  crypto: ^3.0.6

  # Authentication
  local_auth: ^2.3.0

  # Image & file handling
  camera: ^0.11.1
  image_picker: ^1.1.2
  file_picker: ^10.3.7
  photo_view: ^0.15.0
  flutter_pdfview: ^1.4.3

  # State management
  flutter_bloc: ^9.1.1

  # Navigation
  go_router: ^16.0.0

  # Utilities
  uuid: ^4.5.1
  permission_handler: ^12.0.1
  device_info_plus: ^11.5.0

  # Monetization (RevenueCat)
  purchases_flutter: ^9.2.1
  purchases_ui_flutter: ^9.4.0

  # DON'T include these network-dependent packages:
  # firebase_core
  # firebase_analytics
  # dio (HTTP client)
  # http
  # cloud_firestore

Key Principle: Only request permissions you absolutely need, and explain exactly why.

2. Storage: Keep Everything Local

DON'T:

// Using a cloud-synced database
import 'package:cloud_firestore/cloud_firestore.dart';

final db = FirebaseFirestore.instance;
await db.collection('vaults').doc(userId).set({
  'encryptedData': encryptedData,
  'timestamp': FieldValue.serverTimestamp(),
});

DO:

// Using local-only SQLite database
import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

class VaultDatabase {
  static Database? _database;

  Future<Database> get database async {
    if (_database != null) return _database!;
    _database = await _initDatabase();
    return _database!;
  }

  Future<Database> _initDatabase() async {
    final dbPath = await getDatabasesPath();
    final path = join(dbPath, 'vault.db');

    return await openDatabase(
      path,
      version: 1,
      onCreate: (db, version) async {
        await db.execute('''
          CREATE TABLE documents(
            id TEXT PRIMARY KEY,
            encrypted_data BLOB NOT NULL,
            encrypted_thumbnail BLOB,
            created_at INTEGER NOT NULL,
            file_type TEXT NOT NULL
          )
        ''');
      },
    );
  }

  Future<void> saveDocument({
    required String id,
    required List<int> encryptedData,
    List<int>? encryptedThumbnail,
    required String fileType,
  }) async {
    final db = await database;
    await db.insert(
      'documents',
      {
        'id': id,
        'encrypted_data': encryptedData,
        'encrypted_thumbnail': encryptedThumbnail,
        'created_at': DateTime.now().millisecondsSinceEpoch,
        'file_type': fileType,
      },
      conflictAlgorithm: ConflictAlgorithm.replace,
    );
  }

  Future<Map<String, dynamic>?> getDocument(String id) async {
    final db = await database;
    final results = await db.query(
      'documents',
      where: 'id = ?',
      whereArgs: [id],
    );
    return results.isNotEmpty ? results.first : null;
  }

  Future<List<Map<String, dynamic>>> getAllDocuments() async {
    final db = await database;
    return await db.query('documents', orderBy: 'created_at DESC');
  }
}

Alternative: Secure File System Storage

import 'dart:io';
import 'package:path_provider/path_provider.dart';

class SecureFileStorage {
  Future<Directory> get _vaultDirectory async {
    final appDir = await getApplicationDocumentsDirectory();
    final vaultDir = Directory('${appDir.path}/encrypted_vault');

    if (!await vaultDir.exists()) {
      await vaultDir.create(recursive: true);
    }

    return vaultDir;
  }

  Future<void> saveFile(String filename, List<int> encryptedData) async {
    final dir = await _vaultDirectory;
    final file = File('${dir.path}/$filename');
    await file.writeAsBytes(encryptedData);
  }

  Future<List<int>?> readFile(String filename) async {
    try {
      final dir = await _vaultDirectory;
      final file = File('${dir.path}/$filename');
      if (await file.exists()) {
        return await file.readAsBytes();
      }
    } catch (e) {
      print('Error reading file: $e');
    }
    return null;
  }

  Future<void> deleteFile(String filename) async {
    final dir = await _vaultDirectory;
    final file = File('${dir.path}/$filename');
    if (await file.exists()) {
      await file.delete();
    }
  }
}

Key Principle: Use platform-native, local-only storage. SQLite for structured data, file system for blobs.

3. Encryption: Do It Right

DON'T:

// Weak encryption or key management
const key = "MySecretKey123"; // Hard-coded key
final encrypted = encryptData(data, key);

DO:

import 'package:fastcrypt/fastcrypt.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:crypto/crypto.dart';
import 'dart:convert';
import 'dart:typed_data';
import 'dart:math';
import 'dart:isolate';

class EncryptionManager {
  final _secureStorage = const FlutterSecureStorage();
  static const _keyIdentifier = 'vault_encryption_key';
  final _random = Random.secure();

  // Custom header to identify Proof Pocket encrypted files
  static const _header = [0x50, 0x50, 0x46, 0x32]; // 'PPF2'

  // Generate secure random bytes
  Uint8List _generateSecureRandom(int length) {
    final bytes = Uint8List(length);
    for (int i = 0; i < length; i++) {
      bytes[i] = _random.nextInt(256);
    }
    return bytes;
  }

  // Generate and securely store encryption key
  Future<void> generateEncryptionKey() async {
    // Generate a secure 256-bit key for ChaCha20-Poly1305
    final key = _generateSecureRandom(32); // 32 bytes = 256 bits
    await _secureStorage.write(
      key: _keyIdentifier,
      value: base64.encode(key),
      // On Android: uses EncryptedSharedPreferences
      // On iOS: uses Keychain
      aOptions: const AndroidOptions(
        encryptedSharedPreferences: true,
      ),
      iOptions: const IOSOptions(
        accessibility: KeychainAccessibility.first_unlock_this_device,
      ),
    );
  }

  // Retrieve the encryption key
  Future<Uint8List?> _getKey() async {
    final keyString = await _secureStorage.read(key: _keyIdentifier);
    if (keyString == null) return null;
    return Uint8List.fromList(base64.decode(keyString));
  }

  // Encrypt data using ChaCha20-Poly1305 (in background isolate)
  Future<Uint8List> encryptData(Uint8List data) async {
    final key = await _getKey();
    if (key == null) {
      throw Exception('Encryption key not found. Call generateEncryptionKey() first.');
    }

    // Run encryption in isolate to avoid blocking UI
    return await compute(_encryptCompute, {
      'bytes': TransferableTypedData.fromList([data]),
      'key': key.toList(),
    });
  }

  // Encryption computation (runs in isolate)
  static Uint8List _encryptCompute(Map<String, Object> args) {
    final header = _header;
    final bytes = (args['bytes'] as TransferableTypedData)
        .materialize()
        .asUint8List();
    final key = Uint8List.fromList((args['key'] as List).cast<int>());

    // Use FastCrypt for ChaCha20-Poly1305 encryption
    final fc = FastCrypt();
    final enc = fc.encryptBytes(bytes, key: key);

    // Format: [header][nonce][tag][ciphertext]
    return Uint8List.fromList([
      ...header,
      ...enc.nonce,
      ...enc.tag,
      ...enc.ciphertext,
    ]);
  }

  // Decrypt data using ChaCha20-Poly1305 (in background isolate)
  Future<Uint8List> decryptData(Uint8List encryptedData) async {
    final key = await _getKey();
    if (key == null) {
      throw Exception('Encryption key not found');
    }

    // Run decryption in isolate to avoid blocking UI
    return await compute(_decryptCompute, {
      'bytes': TransferableTypedData.fromList([encryptedData]),
      'key': key.toList(),
    });
  }

  // Decryption computation (runs in isolate)
  static Uint8List _decryptCompute(Map<String, Object> args) {
    final header = _header;
    final data = (args['bytes'] as TransferableTypedData)
        .materialize()
        .asUint8List();
    final key = Uint8List.fromList((args['key'] as List).cast<int>());

    // Parse encrypted format: [header][nonce][tag][ciphertext]
    const nonceLen = 12;
    const tagLen = 16;

    if (data.length < header.length + nonceLen + tagLen) {
      throw Exception('Encrypted data not valid or corrupted.');
    }

    // Verify header
    for (var i = 0; i < header.length; i++) {
      if (data[i] != header[i]) {
        throw Exception('Unknown encrypted format.');
      }
    }

    // Extract components
    final offset = header.length;
    final nonce = data.sublist(offset, offset + nonceLen);
    final tag = data.sublist(offset + nonceLen, offset + nonceLen + tagLen);
    final ciphertext = data.sublist(offset + nonceLen + tagLen);

    // Decrypt using FastCrypt
    final fc = FastCrypt();
    return Uint8List.fromList(
      fc.decryptBytes(
        ciphertext: ciphertext,
        nonce: nonce,
        tag: tag,
        key: key,
      ),
    );
  }

  // Hash data (useful for verifying integrity)
  Uint8List hashData(Uint8List data) {
    final digest = sha256.convert(data);
    return Uint8List.fromList(digest.bytes);
  }

  // Check if encryption key exists
  Future<bool> hasEncryptionKey() async {
    final key = await _secureStorage.read(key: _keyIdentifier);
    return key != null;
  }

  // Delete encryption key (for app reset)
  Future<void> deleteEncryptionKey() async {
    await _secureStorage.delete(key: _keyIdentifier);
  }
}

Alternative: Using biometric_storage for extra security

import 'package:biometric_storage/biometric_storage.dart';

class BiometricEncryptionManager {
  StorageFile? _storageFile;

  // Initialize biometric storage
  Future<void> initialize() async {
    final canAuthenticate = await BiometricStorage().canAuthenticate();

    if (canAuthenticate == CanAuthenticateResponse.success) {
      _storageFile = await BiometricStorage().getStorage(
        'vault_key_storage',
        options: StorageFileInitOptions(
          authenticationRequired: true,
          authenticationValidityDurationSeconds: 30,
        ),
      );
    } else {
      throw Exception('Biometric authentication not available');
    }
  }

  // Store encryption key with biometric protection
  Future<void> storeKeyWithBiometrics(String key) async {
    await _storageFile?.write(key);
  }

  // Retrieve key (requires biometric authentication)
  Future<String?> retrieveKeyWithBiometrics() async {
    return await _storageFile?.read();
  }
}

Required packages in pubspec.yaml:

dependencies:
  fastcrypt: ^1.0.0
  crypto: ^3.0.6
  flutter_secure_storage: ^9.2.4
  biometric_storage: ^5.0.1  # Optional, for biometric-protected keys

Key Principles:

Use ChaCha20-Poly1305 (via Fastcrypt) - modern, fast authenticated encryption
Fastcrypt's API: encryptBytes() returns an object with nonce, tag, and ciphertext
Store encrypted format with custom header for file type identification
Run encryption/decryption in background isolates using compute() to avoid blocking UI
ChaCha20-Poly1305 provides both encryption and authentication (no separate MAC needed)
Store keys in platform secure storage:
- iOS: Keychain
- Android: EncryptedSharedPreferences (uses Android Keystore)
Never hard-code keys
Custom file format: [Header: 4 bytes][Nonce: 12 bytes][Tag: 16 bytes][Ciphertext: variable]
Consider biometric_storage for extra protection of encryption keys

Why ChaCha20-Poly1305?

Faster than AES on mobile devices without hardware AES acceleration
Authenticated encryption (prevents tampering)
Widely used and well-vetted (used in TLS, Signal, WhatsApp)
No timing attack vulnerabilities

Why use isolates for encryption?

Prevents UI blocking for large files
Better performance on multi-core devices
compute() handles isolate communication automatically

4. Authentication: Use Device Security

DON'T:

// Custom authentication that might leak credentials
class AuthService {
  Future<void> login(String username, String password) async {
    final response = await api.login(username, password);
    // Credentials sent to server
  }
}

DO:

import 'package:local_auth/local_auth.dart';
import 'package:permission_handler/permission_handler.dart';

class BiometricAuth {
  final LocalAuthentication _auth = LocalAuthentication();

  // Check if device supports biometrics
  Future<bool> canUseBiometrics() async {
    try {
      return await _auth.canCheckBiometrics;
    } catch (e) {
      return false;
    }
  }

  // Check if device has biometrics enrolled
  Future<bool> isDeviceSupported() async {
    try {
      return await _auth.isDeviceSupported();
    } catch (e) {
      return false;
    }
  }

  // Get available biometric types
  Future<List<BiometricType>> getAvailableBiometrics() async {
    try {
      return await _auth.getAvailableBiometrics();
    } catch (e) {
      return [];
    }
  }

  // Authenticate user with biometrics or device PIN/password
  Future<bool> authenticateUser() async {
    try {
      final canCheckBiometrics = await canUseBiometrics();
      final isSupported = await isDeviceSupported();

      if (!canCheckBiometrics || !isSupported) {
        // Fall back to device credentials (PIN/password/pattern)
        return await _authenticateWithDeviceCredentials();
      }

      // Try biometric authentication
      final authenticated = await _auth.authenticate(
        localizedReason: 'Unlock your encrypted vault',
        options: const AuthenticationOptions(
          stickyAuth: true,
          biometricOnly: false, // Allow PIN fallback
          useErrorDialogs: true,
          sensitiveTransaction: true,
        ),
      );

      return authenticated;
    } catch (e) {
      print('Authentication error: $e');
      return false;
    }
  }

  // Authenticate with device credentials only (no biometrics)
  Future<bool> _authenticateWithDeviceCredentials() async {
    try {
      return await _auth.authenticate(
        localizedReason: 'Unlock your encrypted vault',
        options: const AuthenticationOptions(
          stickyAuth: true,
          biometricOnly: false,
          useErrorDialogs: true,
        ),
      );
    } catch (e) {
      print('Device credentials error: $e');
      return false;
    }
  }

  // Stop authentication
  Future<void> stopAuthentication() async {
    await _auth.stopAuthentication();
  }
}

// Usage example with permission handling
class VaultAccessManager {
  final BiometricAuth _biometricAuth = BiometricAuth();

  // Request biometric permissions (Android 11+)
  Future<bool> requestBiometricPermission() async {
    if (Platform.isAndroid) {
      final status = await Permission.biometric.request();
      return status.isGranted;
    }
    return true; // iOS doesn't need explicit permission request
  }

  Future<bool> unlockVault() async {
    // Request permission first (Android)
    final hasPermission = await requestBiometricPermission();
    if (!hasPermission) {
      return false;
    }

    // Authenticate user
    final authenticated = await _biometricAuth.authenticateUser();

    if (authenticated) {
      // User is authenticated, allow vault access
      return true;
    } else {
      // Authentication failed
      return false;
    }
  }
}

Android-specific configuration (AndroidManifest.xml):

<manifest>
    <uses-permission android:name="android.permission.USE_BIOMETRIC"/>
    <!-- For older Android versions -->
    <uses-permission android:name="android.permission.USE_FINGERPRINT"/>
</manifest>

iOS-specific configuration (Info.plist):

<key>NSFaceIDUsageDescription</key>
<string>Unlock your encrypted vault using Face ID</string>

Required packages:

dependencies:
  local_auth: ^2.3.0
  permission_handler: ^12.0.1

Key Principle: Leverage device-level security instead of custom authentication systems. No passwords to store, no credentials to leak.

5. No Analytics: Build Blind

DON'T:

// Tracking user behavior
import 'package:firebase_analytics/firebase_analytics.dart';

final analytics = FirebaseAnalytics.instance;
await analytics.logEvent(
  name: 'document_added',
  parameters: {
    'document_type': 'passport',
    'file_size': fileSize,
  },
);

DO:

// Nothing. Just don't track.

// If you MUST understand usage (for debugging), use local-only logging
class PrivacyPreservingLogger {
  void logEvent(String event, [Map<String, dynamic>? params]) {
    // In debug mode only
    assert(() {
      print('Event: $event');
      if (params != null) print('Params: $params');
      return true;
    }());
    // In production: nothing. No tracking, period.
  }
}

Alternative: Privacy-Preserving Telemetry (If You Must)

If you absolutely need some usage data, consider:

import 'package:shared_preferences/shared_preferences.dart';

// Local-only, aggregated, anonymous stats
class LocalAnalytics {
  static const _prefix = 'analytics_';

  Future<void> incrementCounter(String event) async {
    final prefs = await SharedPreferences.getInstance();
    final key = '$_prefix$event';
    final current = prefs.getInt(key) ?? 0;
    await prefs.setInt(key, current + 1);
  }

  // Stats never leave the device
  // User can view them in Settings if they want
  Future<Map<String, int>> getStats() async {
    final prefs = await SharedPreferences.getInstance();
    final stats = <String, int>{};

    for (final key in prefs.getKeys()) {
      if (key.startsWith(_prefix)) {
        final eventName = key.substring(_prefix.length);
        stats[eventName] = prefs.getInt(key) ?? 0;
      }
    }

    return stats;
  }

  // Allow users to clear their local stats
  Future<void> clearStats() async {
    final prefs = await SharedPreferences.getInstance();
    for (final key in prefs.getKeys()) {
      if (key.startsWith(_prefix)) {
        await prefs.remove(key);
      }
    }
  }
}

Key Principle: If you can't see the data, you can't leak it.

6. Network Isolation: Enforce It

AndroidManifest.xml Configuration:

<!-- Explicitly do NOT request internet permission -->
<!-- If not declared, app cannot access network -->
<!-- Only include permissions you actually need: -->
<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

iOS Info.plist Configuration:

<!-- Disable ATS to prevent any network access -->
<key>NSAppTransportSecurity</key>
<dict>
    <key>NSAllowsArbitraryLoads</key>
    <false/>
</dict>

Code-Level Enforcement:

import 'package:connectivity_plus/connectivity_plus.dart';

// Create a network monitor to ensure offline operation
class NetworkGuard {
  static final NetworkGuard _instance = NetworkGuard._internal();
  factory NetworkGuard() => _instance;
  NetworkGuard._internal();

  final _connectivity = Connectivity();

  void initialize() {
    _connectivity.onConnectivityChanged.listen((result) {
      if (result != ConnectivityResult.none) {
        // Network is available, but we don't use it
        _logWarning('Network detected but not used (offline-first)');
      }
    });
  }

  void _logWarning(String message) {
    assert(() {
      print('⚠️ NetworkGuard: $message');
      return true;
    }());
  }
}

// Initialize in main.dart
void main() {
  NetworkGuard().initialize();
  runApp(MyApp());
}

Verify No Network Packages in pubspec.yaml:

dependencies:
  # ✅ GOOD - Local only
  sqflite: ^2.3.0
  path_provider: ^2.1.1
  shared_preferences: ^2.2.2

  # ❌ BAD - Remove these
  # http: 
  # dio:
  # firebase_core:
  # cloud_firestore:

Key Principle: Make network access impossible by not requesting permissions, not just unused.

Advanced Topics

Handling Photos & PDFs

import 'dart:io';
import 'dart:typed_data';
import 'package:camera/camera.dart';
import 'package:image_picker/image_picker.dart';
import 'package:file_picker/file_picker.dart';
import 'package:flutter_pdfview/flutter_pdfview.dart';

class DocumentProcessor {
  final EncryptionManager _encryption = EncryptionManager();
  final ImagePicker _picker = ImagePicker();

  // Capture photo using camera
  Future<Uint8List?> capturePhotoWithCamera() async {
    try {
      final cameras = await availableCameras();
      if (cameras.isEmpty) {
        throw Exception('No cameras available');
      }

      // You would typically navigate to a camera screen here
      // and return the captured image bytes
      // This is a simplified example

      final XFile? photo = await _picker.pickImage(
        source: ImageSource.camera,
        maxWidth: 1920,
        maxHeight: 1920,
        imageQuality: 85,
      );

      if (photo == null) return null;

      final imageBytes = await photo.readAsBytes();

      // Encrypt immediately
      return await _encryption.encryptData(imageBytes);
    } catch (e) {
      print('Error capturing photo: $e');
      return null;
    }
  }

  // Import photo from gallery
  Future<Uint8List?> importPhotoFromGallery() async {
    try {
      final XFile? pickedFile = await _picker.pickImage(
        source: ImageSource.gallery,
        maxWidth: 1920,
        maxHeight: 1920,
        imageQuality: 85,
      );

      if (pickedFile == null) return null;

      final imageBytes = await pickedFile.readAsBytes();

      // Encrypt immediately
      return await _encryption.encryptData(imageBytes);
    } catch (e) {
      print('Error importing photo: $e');
      return null;
    }
  }

  // Import PDF file using file_picker
  Future<Uint8List?> importPDF() async {
    try {
      FilePickerResult? result = await FilePicker.platform.pickFiles(
        type: FileType.custom,
        allowedExtensions: ['pdf'],
        allowMultiple: false,
      );

      if (result == null || result.files.isEmpty) return null;

      final file = File(result.files.single.path!);
      final pdfBytes = await file.readAsBytes();

      // Validate PDF size (prevent DoS)
      if (pdfBytes.length > 10 * 1024 * 1024) { // 10MB limit
        throw Exception('PDF file too large (max 10MB)');
      }

      // Encrypt immediately
      return await _encryption.encryptData(pdfBytes);
    } catch (e) {
      print('Error importing PDF: $e');
      return null;
    }
  }

  // Generate thumbnail from encrypted image
  Future<Uint8List?> generateThumbnail(Uint8List encryptedImageData) async {
    try {
      // Decrypt temporarily to generate thumbnail
      final decryptedBytes = await _encryption.decryptData(encryptedImageData);

      // For production, use image processing library
      // This is simplified - you'd want to resize the image
      final thumbnailBytes = decryptedBytes; // Placeholder

      // In production, resize to 200x200 using image package
      // final image = img.decodeImage(decryptedBytes);
      // final thumbnail = img.copyResize(image, width: 200, height: 200);
      // final thumbnailBytes = img.encodeJpg(thumbnail, quality: 70);

      // Re-encrypt thumbnail
      return await _encryption.encryptData(thumbnailBytes);
    } catch (e) {
      print('Error generating thumbnail: $e');
      return null;
    }
  }

  // Display encrypted PDF (decrypt in memory, don't save)
  Future<void> displayEncryptedPDF(
    Uint8List encryptedPdfData,
    String tempFilePath,
  ) async {
    try {
      // Decrypt PDF
      final decryptedPdf = await _encryption.decryptData(encryptedPdfData);

      // Write to temporary file for PDFView widget
      final tempFile = File(tempFilePath);
      await tempFile.writeAsBytes(decryptedPdf);

      // Use flutter_pdfview to display:
      // PDFView(
      //   filePath: tempFilePath,
      //   enableSwipe: true,
      //   onError: (error) => print(error),
      //   onPageError: (page, error) => print('$page: ${error.toString()}'),
      // )

      // IMPORTANT: Delete temp file after viewing
      await tempFile.delete();
    } catch (e) {
      print('Error displaying PDF: $e');
    }
  }
}

Required packages:

dependencies:
  camera: ^0.11.1
  image_picker: ^1.1.2
  file_picker: ^10.3.7
  flutter_pdfview: ^1.4.3
  # Optional: for advanced image processing
  # image: ^4.1.3

Key Principle: Encrypt everything immediately after import. Only decrypt temporarily when needed for display, never save decrypted data.

Data Export (User Control)

import 'dart:io';
import 'dart:convert';
import 'package:path_provider/path_provider.dart';
import 'package:share_plus/share_plus.dart'; // Optional: for sharing files

class DataExporter {
  final VaultDatabase _database = VaultDatabase();

  // Export all encrypted data to a directory
  Future<Directory?> exportAllData() async {
    try {
      final appDir = await getApplicationDocumentsDirectory();
      final timestamp = DateTime.now().millisecondsSinceEpoch;
      final exportDir = Directory('${appDir.path}/vault_export_$timestamp');
      await exportDir.create(recursive: true);

      // Get all documents from database
      final documents = await _database.getAllDocuments();

      // Copy all encrypted files to export directory
      for (var i = 0; i < documents.length; i++) {
        final doc = documents[i];
        final encryptedData = doc['encrypted_data'] as List<int>;
        final file = File('${exportDir.path}/document_$i.enc');
        await file.writeAsBytes(encryptedData);
      }

      // Create metadata file
      final metadata = {
        'export_date': DateTime.now().toIso8601String(),
        'document_count': documents.length,
        'version': '1.0',
        'app': 'Proof Pocket',
      };
      final metadataFile = File('${exportDir.path}/metadata.json');
      await metadataFile.writeAsString(jsonEncode(metadata));

      return exportDir;
    } catch (e) {
      print('Error exporting data: $e');
      return null;
    }
  }

  // Import from exported directory
  Future<bool> importData(Directory exportDir) async {
    try {
      // Read metadata
      final metadataFile = File('${exportDir.path}/metadata.json');
      if (!await metadataFile.exists()) {
        throw Exception('Invalid backup: missing metadata');
      }

      final metadataContent = await metadataFile.readAsString();
      final metadata = jsonDecode(metadataContent) as Map<String, dynamic>;

      print('Importing ${metadata['document_count']} documents...');

      // Import encrypted documents
      final files = exportDir.listSync()
          .where((f) => f.path.endsWith('.enc'))
          .cast<File>();

      for (final file in files) {
        final encryptedData = await file.readAsBytes();
        await _database.saveDocument(
          id: uuid.v4(), // Generate new ID
          encryptedData: encryptedData,
          fileType: 'imported',
        );
      }

      return true;
    } catch (e) {
      print('Error importing data: $e');
      return false;
    }
  }

  // Create a single backup file (all docs in one file)
  Future<File?> createBackupFile() async {
    try {
      final tempDir = await getTemporaryDirectory();
      final timestamp = DateTime.now().millisecondsSinceEpoch;
      final backupFile = File('${tempDir.path}/proof_pocket_backup_$timestamp.ppb');

      final documents = await _database.getAllDocuments();

      // Create backup structure
      final backup = {
        'version': '1.0',
        'export_date': DateTime.now().toIso8601String(),
        'documents': documents.map((doc) => {
          'id': doc['id'],
          'encrypted_data': base64.encode(doc['encrypted_data'] as List<int>),
          'file_type': doc['file_type'],
          'created_at': doc['created_at'],
        }).toList(),
      };

      // Write as JSON
      await backupFile.writeAsString(jsonEncode(backup));

      return backupFile;
    } catch (e) {
      print('Error creating backup: $e');
      return null;
    }
  }

  // Restore from backup file
  Future<bool> restoreFromBackup(File backupFile) async {
    try {
      final content = await backupFile.readAsString();
      final backup = jsonDecode(content) as Map<String, dynamic>;

      final documents = backup['documents'] as List<dynamic>;

      for (final doc in documents) {
        final encryptedData = base64.decode(doc['encrypted_data'] as String);
        await _database.saveDocument(
          id: doc['id'] as String,
          encryptedData: encryptedData,
          fileType: doc['file_type'] as String,
        );
      }

      return true;
    } catch (e) {
      print('Error restoring backup: $e');
      return false;
    }
  }
}

Required packages:

dependencies:
  path_provider: ^2.1.5
  uuid: ^4.5.1
  # Optional for sharing:
  # share_plus: ^7.2.1

Key Principle: Give users full control over their data without involving servers. All export/import happens locally. Users can manually transfer backup files between devices.

Testing Privacy Compliance

1. Network Traffic Analysis

# Use Charles Proxy or mitmproxy to monitor network
# Your app should show ZERO network requests

# Android: Use adb logcat
adb logcat | grep -i "http\|network\|socket"

# Should return nothing related to your app

# iOS Simulator
xcrun simctl spawn booted log stream --predicate 'process == "Runner"' | grep -i "http"

# Should return nothing

2. Permission Auditing

// Create a test to verify no unexpected permissions
import 'package:flutter_test/flutter_test.dart';
import 'dart:io';

void main() {
  test('Android manifest has only required permissions', () async {
    final manifestFile = File('android/app/src/main/AndroidManifest.xml');
    final manifest = await manifestFile.readAsString();

    // Define allowed permissions
    final allowedPermissions = [
      'android.permission.CAMERA',
      'android.permission.READ_EXTERNAL_STORAGE',
      'android.permission.WRITE_EXTERNAL_STORAGE',
      'android.permission.USE_BIOMETRIC',
    ];

    // Check for INTERNET permission (should NOT exist)
    expect(manifest.contains('android.permission.INTERNET'), false,
        reason: 'App should not request INTERNET permission');

    // Verify no unexpected permissions
    final permissionRegex = RegExp(r'<uses-permission android:name="([^"]+)"');
    final matches = permissionRegex.allMatches(manifest);

    for (final match in matches) {
      final permission = match.group(1)!;
      final permissionName = permission.split('.').last;
      expect(allowedPermissions.contains(permission), true,
          reason: 'Unexpected permission: $permission');
    }
  });

  test('pubspec.yaml has no network packages', () async {
    final pubspecFile = File('pubspec.yaml');
    final pubspec = await pubspecFile.readAsString();

    // Packages that should NOT be present
    final bannedPackages = [
      'http:',
      'dio:',
      'firebase_core:',
      'firebase_analytics:',
      'cloud_firestore:',
    ];

    for (final package in bannedPackages) {
      expect(pubspec.contains(package), false,
          reason: 'Network package detected: $package');
    }
  });
}

3. Storage Verification

import 'package:flutter_test/flutter_test.dart';

void main() {
  test('Verify encryption is applied before storage', () async {
    final encryption = EncryptionManager();
    final database = VaultDatabase();

    // Generate key
    await encryption.generateEncryptionKey();

    // Test data
    final originalData = Uint8List.fromList([1, 2, 3, 4, 5]);

    // Encrypt
    final encryptedData = await encryption.encryptData(originalData);

    // Verify encrypted data is different from original
    expect(encryptedData, isNot(equals(originalData)));
    expect(encryptedData.length, greaterThan(originalData.length));

    // Save to database
    await database.saveDocument(
      id: 'test-doc',
      encryptedData: encryptedData,
      fileType: 'test',
    );

    // Retrieve and verify
    final retrieved = await database.getDocument('test-doc');
    expect(retrieved, isNotNull);
    expect(retrieved!['encrypted_data'], equals(encryptedData));

    // Decrypt and verify
    final decrypted = await encryption.decryptData(
      Uint8List.fromList(retrieved['encrypted_data'] as List<int>)
    );
    expect(decrypted, equals(originalData));
  });
}

4. Integration Testing

// integration_test/privacy_test.dart
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();

  testWidgets('App functions completely offline', (tester) async {
    // Launch app
    // Verify it loads without network
    // Perform key operations (add document, encrypt, decrypt)
    // All should work without network access
  });
}

The Monetization Question

"How do I make money if I don't track users?"

Simple: In-app purchases or subscriptions for features, not for data access.

For Proof Pocket, I use RevenueCat - a privacy-friendly monetization platform that handles subscriptions and one-time purchases without requiring your own backend.

import 'package:purchases_flutter/purchases_flutter.dart';
import 'package:purchases_ui_flutter/purchases_ui_flutter.dart';

class PurchaseManager {
  static const String revenueCatApiKey = 'your_revenuecat_api_key';

  // Initialize RevenueCat (call this on app start)
  static Future<void> initialize() async {
    await Purchases.setLogLevel(LogLevel.debug); // Only in debug

    PurchasesConfiguration configuration = PurchasesConfiguration(revenueCatApiKey);
    await Purchases.configure(configuration);
  }

  // Check if user has active subscription or lifetime access
  Future<bool> hasProAccess() async {
    try {
      CustomerInfo customerInfo = await Purchases.getCustomerInfo();

      // Check for active entitlements
      return customerInfo.entitlements.active.containsKey('pro');
    } catch (e) {
      print('Error checking pro access: $e');
      return false;
    }
  }

  // Show paywall using RevenueCat's UI
  Future<bool> showPaywall() async {
    try {
      final paywallResult = await RevenueCatUI.presentPaywall();

      // Check if purchase was successful
      if (paywallResult == PaywallResult.purchased) {
        return true;
      }

      return false;
    } catch (e) {
      print('Error showing paywall: $e');
      return false;
    }
  }

  // Manual purchase flow (if you want custom UI)
  Future<bool> purchaseProduct(String productId) async {
    try {
      // Get available offerings
      Offerings offerings = await Purchases.getOfferings();

      if (offerings.current == null) {
        print('No offerings available');
        return false;
      }

      // Find the product
      Package? package = offerings.current!.availablePackages
          .firstWhere(
            (p) => p.identifier == productId,
            orElse: () => throw Exception('Product not found'),
          );

      // Make purchase
      CustomerInfo customerInfo = await Purchases.purchasePackage(package);

      // Check if purchase was successful
      return customerInfo.entitlements.active.containsKey('pro');
    } catch (e) {
      print('Purchase error: $e');
      return false;
    }
  }

  // Restore purchases
  Future<bool> restorePurchases() async {
    try {
      CustomerInfo customerInfo = await Purchases.restorePurchases();
      return customerInfo.entitlements.active.containsKey('pro');
    } catch (e) {
      print('Restore error: $e');
      return false;
    }
  }

  // Get current offerings (products available)
  Future<Offerings?> getOfferings() async {
    try {
      return await Purchases.getOfferings();
    } catch (e) {
      print('Error getting offerings: $e');
      return null;
    }
  }
}

// Usage in your app
class VaultApp extends StatefulWidget {
  @override
  _VaultAppState createState() => _VaultAppState();
}

class _VaultAppState extends State<VaultApp> {
  final _purchaseManager = PurchaseManager();
  bool _hasProAccess = false;

  @override
  void initState() {
    super.initState();
    _checkProAccess();
  }

  Future<void> _checkProAccess() async {
    final hasAccess = await _purchaseManager.hasProAccess();
    setState(() {
      _hasProAccess = hasAccess;
    });
  }

  Future<void> _showUpgradeDialog() async {
    final purchased = await _purchaseManager.showPaywall();
    if (purchased) {
      await _checkProAccess();
    }
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        body: _hasProAccess 
            ? ProFeatures() 
            : FreeFeatures(onUpgrade: _showUpgradeDialog),
      ),
    );
  }
}

Required packages:

dependencies:
  purchases_flutter: ^9.2.1
  purchases_ui_flutter: ^9.4.0  # Optional: for pre-built paywall UI

Why RevenueCat for privacy-first apps:

✅ No need to build your own backend
✅ Handles App Store/Play Store validation
✅ Works completely client-side (no server needed)
✅ Privacy-focused (they don't sell your user data)
✅ Anonymous user IDs (no email required)
✅ Cross-platform (iOS & Android with one codebase)

Pricing Model:

Free tier: 2 encrypted documents
Yearly subscription: Unlimited documents + support
One-time lifetime purchase: Full access forever

Key Principle: Charge for features, not for access to user data. RevenueCat handles the complex subscription logic without requiring you to track users or build a backend.

Common Objections (And Responses)

"But users want cloud sync!"

Some do. But there's a market for people who value privacy over convenience. Target them.

You can also support manual export/import for cross-device usage without servers.

"How will I debug without crash reporting?"

Use local logging in debug builds. Encourage users to report issues manually (with their permission).

Note: Proof Pocket does use Sentry for crash reporting, but it's configured to be privacy-preserving - no user data is sent, only crash stack traces. This is a tradeoff between being completely offline and being able to fix bugs.

import 'package:flutter/foundation.dart';
import 'package:logging/logging.dart';

class DebugLogger {
  static final Logger _logger = Logger('ProofPocket');

  static void initialize() {
    // Only log in debug mode
    if (kDebugMode) {
      Logger.root.level = Level.ALL;
      Logger.root.onRecord.listen((record) {
        print('${record.level.name}: ${record.time}: ${record.message}');
        if (record.error != null) {
          print('Error: ${record.error}');
        }
        if (record.stackTrace != null) {
          print('Stack trace:\n${record.stackTrace}');
        }
      });
    }
  }

  static void log(String message, [Level level = Level.INFO]) {
    if (kDebugMode) {
      _logger.log(level, message);
    }
    // In release mode: nothing gets logged locally
  }

  static void error(String message, [Object? error, StackTrace? stackTrace]) {
    if (kDebugMode) {
      _logger.severe(message, error, stackTrace);
    }
  }

  static void warning(String message) {
    if (kDebugMode) {
      _logger.warning(message);
    }
  }

  static void info(String message) {
    if (kDebugMode) {
      _logger.info(message);
    }
  }
}

// Usage
try {
  await someOperation();
  DebugLogger.info('Operation completed successfully');
} catch (e, stackTrace) {
  DebugLogger.error('Operation failed', e, stackTrace);
  // In debug: logs to console
  // In release: silent (or sent to Sentry if configured)
}

If using Sentry (privacy-preserving configuration):

import 'package:sentry_flutter/sentry_flutter.dart';

Future<void> main() async {
  await SentryFlutter.init(
    (options) {
      options.dsn = 'your-sentry-dsn';
      options.environment = kDebugMode ? 'debug' : 'production';

      // Privacy settings
      options.sendDefaultPii = false; // Don't send user info
      options.attachStacktrace = true; // Only stack traces

      // Don't capture user interactions or breadcrumbs
      options.enableAutoSessionTracking = false;

      // Filter out sensitive data
      options.beforeSend = (event, {hint}) {
        // Remove any potentially sensitive data from events
        event = event.copyWith(
          user: null, // Remove user info
          contexts: null, // Remove device context
        );
        return event;
      };
    },
    appRunner: () => runApp(MyApp()),
  );
}

Required package:

dependencies:
  logging: ^1.3.0
  sentry_flutter: ^9.6.0  # Optional, for privacy-aware crash reporting

"How will I know if anyone uses it?"

App Store Connect provides download numbers. That's all you need.

Feature usage can be tracked locally (on-device only) and shown to users in settings.

Conclusion

Building truly private apps requires intentional architectural decisions:

✅ DO:

Use offline-first architecture
Store everything locally with encryption
Request minimal permissions
Leverage device-level security
Give users full data control
Be transparent about what you do (and don't do)

❌ DON'T:

Integrate third-party SDKs without auditing them
Use cloud services "just because"
Track user behavior (even anonymously)
Assume users won't notice privacy violations

The tradeoff is real: You sacrifice analytics, cloud sync, and some convenience features.

The reward is also real: You build trust with privacy-conscious users, avoid data breach liability, and sleep better at night knowing you're not part of the surveillance capitalism machine.

Resources

Flutter & Dart Documentation:

Platform-Specific Security:

Privacy Best Practices:

About

I built Proof Pocket using these principles — an offline-first vault app for iOS and Android (built with Flutter) that stores encrypted documents without any server infrastructure. You can find it on the App Store and Google Play.

Questions? Disagree with something? Drop a comment below. I'd love to hear how other Flutter developers are approaching privacy-first app development.

Code examples are simplified for clarity. Always conduct security audits and testing for production apps.

Building Proof Pocket: An Offline Encrypted Vault for Your Photos and Documents

Karol Burdziński — Thu, 11 Dec 2025 13:07:58 +0000

As a developer and frequent traveler, I was frustrated with how cloud-based storage apps handle sensitive documents. Even “secure” apps can leak metadata, require accounts, or store your data on servers you don’t control.

That’s why I built Proof Pocket — a mobile app for storing photos and documents completely offline. Everything stays on your device, and users don’t have to trust any server.

🔒 Encryption & Security

To secure data on-device, I used ChaCha20-Poly1305, which provides both confidentiality and integrity. Here’s why I chose it:

Fast and lightweight — perfect for mobile devices

Authenticated encryption — protects both data and integrity

Widely regarded as secure — used in TLS, WireGuard, and other modern protocols

All files are encrypted locally, stored in the phone’s secure storage, and never leave the device. There’s no analytics, no tracking, and no hidden cloud sync.

💡 Offline-First Design

The app is designed to work entirely without internet access:

Users can add, view, and organize documents anytime

Everything is persisted securely on-device

No network dependency means true privacy

💰 Freemium Model

Proof Pocket is free to try:

Store up to 2 documents/photos for free

All features unlock via a yearly subscription or a one-time lifetime unlock

📱 Available On

Android: [Play Store Link]

iOS: [App Store Link]

📝 Lessons Learned

Offline-first apps force you to carefully manage local storage and encryption performance.

Choosing a fast, mobile-friendly cipher like ChaCha20-Poly1305 is crucial to avoid lag on lower-end devices.
AES is also fine as most mobile devices got AES hardware acceleration already, but as both of those were pretty fast I decided to go with the ChaCha having similar level of secureness.

I’d love to hear feedback from fellow developers and privacy enthusiasts — especially on UI, encryption approach, or potential improvements.