# How to Vibe Code Your Own Ente (and Stop Paying for It) > End-to-end encrypted, cross-platform photo storage - Site: https://ente.io - Category: Cloud Storage & Privacy - Platforms: iOS app, Android app, macOS app, Windows app, Linux app, Web app - Verdict: **Serious undertaking** (38/100 vibecodeable) - Estimated effort: 3-5 months of part-time development ## Verdict You can build a personal photo sync subset, but client-side E2EE key management and robust cross-platform mobile background daemons require significant systems engineering. Building a personal alternative to Ente means writing cross-platform Flutter clients that handle heavy local encryption/decryption keys entirely in client storage while communicating with a custom Go backend. The hardest trap is not the server API, but fighting mobile operating systems to keep background sync alive without draining device batteries, alongside maintaining buttery-smooth thumbnail rendering for massive media libraries. ### What you can't replicate - The years of iterative bug fixes for cross-platform background sync edge cases across fragmented Android devices - Independent third-party cryptographic audits providing verified zero-knowledge security guarantees - The pre-existing multi-platform ecosystem and native integration polish ## What it does An open-source, zero-knowledge alternative to mainstream cloud storage providers like Google Photos and Apple Photos with end-to-end encryption, local AI face recognition, and automatic background sync. ### Core features - Client-side end-to-end encryption (E2EE) key management - Automated mobile background media syncing daemon - Cross-platform client UI rendering thousands of grid thumbnails smoothly (Flutter) - Encrypted cloud object storage integration (S3-compatible) - On-device face detection and natural language metadata indexing - Secure album sharing and public link generation with zero-knowledge keys ## The business ### Pricing - Free Forever: Free — 10 GB storage with full E2EE features and local AI - Starter: $2.49/mo — 50 GB storage with family sharing - Popular: $4.99/mo — 200 GB storage - Pro: $9.99/mo — 1000 GB storage - Pro+: $19.99/mo — 2000 GB storage Founded 2020. Team size: 10–15 team members. ## The hard parts - Rigorous zero-knowledge cryptographic protocol implementation ensuring keys never touch the server - Managing aggressive background process termination rules on iOS and Android during large library syncs - Cross-platform UI performance optimization for high-density media grids across mobile and desktop - Chunked encryption and efficient bandwidth/storage management for large raw video and image files ## How to vibe code Ente ### Prerequisites - Flutter SDK (free): Cross-platform mobile and desktop client development framework - Go (free): Building the backend API server (Museum) - Docker (free): Running local and production containerized backend environments - GitHub (free): Code repository hosting and CI/CD pipelines ### Recommended AI tools - Claude Code: Best-in-class multi-file agent for scaffolding both the Go server and Flutter mobile code structures - Cursor: IDE for iterative UI layout design and debugging client-side cryptographic functions ### Stack - Frontend: Flutter (Dart) - Backend: Golang (Go) - Database: PostgreSQL - Auth: Custom client-derived master keys / token-based auth - Payments: None (personal self-hosted clone) - Other: S3-compatible Object Storage (Backblaze B2), Docker & Traefik ### Hosting - Fly.io (Hosting the Go backend API container and PostgreSQL database): $5-10/mo - Backblaze B2 (Encrypted chunk object storage for photos and videos): $6/TB/mo ### Build guide 1. **Scaffold the Go Backend API** — Initialize a modular Go project with a clean architecture layout. Implement database migrations for users, files, metadata, and sharing tokens using PostgreSQL. ``` Create a new Go backend project using Chi or Gin router. Set up a PostgreSQL database connection pool using pgx. Implement database models and migrations for users (id, email, password_hash, master_key_salt), files (id, user_id, encrypted_metadata, size, checksum, storage_path, created_at), and albums. Include structured JSON logging, graceful shutdown, and a health check endpoint. Write comprehensive unit tests for user registration and file metadata record creation. ``` 2. **Implement S3-Compatible Storage Integration** — Add an abstraction layer in the Go backend to stream encrypted file chunks directly to an S3-compatible bucket (such as Backblaze B2 or local MinIO for development). ``` Add an object storage service package to the Go backend using the official AWS SDK for Go v2. Implement methods to generate presigned upload and download URLs, handle multipart streaming for large encrypted video files, and delete file objects securely from the bucket. Ensure the service supports configurable S3-compatible endpoints for Backblaze B2 or self-hosted S3 storage. ``` 3. **Build Client-Side Encryption Core (Flutter)** — Develop the cryptographic utility module in Flutter using point-to-point encryption primitives. Ensure keys are derived securely and never transmitted to the server in plaintext. ``` Create a Dart cryptographic module using point-to-point encryption libraries. Implement key derivation functions (PBKDF2/Argon2) to generate a client-side master key from user passphrases. Implement authenticated encryption (AES-GCM) for encrypting local file bytes and JSON metadata structures before upload, along with corresponding decryption routines for downloads. Write unit tests verifying that zero plaintext metadata or master keys escape the client boundary. ``` 4. **Construct Flutter Cross-Platform Client Shell & Gallery Grid** — Set up the multi-platform Flutter app structure with state management, secure local storage for keys, and a high-performance virtualized media grid view. ``` Scaffold a Flutter cross-platform mobile application supporting iOS and Android. Implement state management using Riverpod or Bloc. Set up secure local storage (flutter_secure_storage) for holding client encryption keys. Create a responsive photo gallery grid view with local caching and thumbnail lazy-loading using custom photo manager plugins to ensure smooth scrolling performance over thousands of local items. ``` 5. **Implement Background Upload Daemon** — Build a reliable background service daemon in Flutter that monitors local device asset changes and pushes encrypted chunks to the Go backend API. ``` Implement a background service worker in Flutter (using workmanager or native platform background fetch APIs) that periodically checks for new local media assets. The worker must fetch unbacked-up local items, read file bytes, encrypt them using the client-side encryption module, upload chunks to the Go backend API with retry backoff logic, and update local synchronization state tables. ``` 6. **Build Album Sharing and Public Links** — Add backend routes and client UI for creating shared albums and public cryptographic view links with granular permissions. ``` Implement album sharing logic in the Go backend allowing users to create collaborative albums and grant access tokens to other users or generate public view links. Add endpoints for sharing encrypted file keys re-encrypted for recipient public keys. In the Flutter client, add UI screens for viewing shared albums, accepting invitations, and rendering decrypted shared media items seamlessly. ``` 7. **Containerize and Deploy Infrastructure** — Dockerize the Go backend service and deploy it alongside a PostgreSQL database instance to Fly.io, configuring environment variables and reverse proxy routing. ``` Create a multi-stage Dockerfile for the Go backend application ensuring a minimal production image size. Write a fly.toml configuration file for deployment on Fly.io, including persistent volume mounts for local assets if needed, environment variables for S3 credentials, database connection strings, and secret keys. Document environment setup and deployment steps in a clear README. ``` ### Cost vs paying **Starting costs (one-time):** - AI Coding Tools subscription: $20 - Total: $20 one-time **Ongoing costs (monthly):** - Fly.io Backend Compute: $5/mo - Backblaze B2 Object Storage (per TB): $6/mo - Total: ~$11/mo - Paying for the SaaS instead: $4.99/mo (Popular 200GB plan) - Build time: 60-90 hours - AI tool credits: $20 (1 month of Claude Code / Cursor Pro) - Break-even: Never (purely for privacy control and self-hosting satisfaction) ## Sources - [Ente Official Website](https://ente.io) - [Ente GitHub Organization](https://github.com/ente-io) - [Reddit AMA with Vishnu Mohandas (Founder and CEO)](https://www.reddit.com/r/developersIndia/comments/1freooh/im_vishnu_mohandas_founder_and_ceo_at_ente_ama/) - [EdyTheCow Self-Hosting Guide & Architecture breakdown](https://github.com/EdyTheCow/ente-selfhost)