Hello ICP community,
Over the past three years, I’ve been working toward a career in software engineering. I’ve spent more than a year learning about the Internet Computer, and I’d like to share a project I’ve been building: a browser-based encrypted backup application.
I’m a junior developer, and I started this project hoping to become a solo founder and build a backup solution that businesses could use. As I worked on it, I began to understand how much more it takes to turn an implementation into a reliable product that companies can trust with their data.
That has been a humbling learning experience. I’ve decided to share the idea and code publicly, get feedback, and learn from people with more experience. I’m still improving how I structure code and design systems, but I’m proud of how far I’ve come.
Source code: https://github.com/ImSteffi/ICP_backup
What the application does
Users can select files and folders, encrypt them in the browser, distribute the encrypted chunks across multiple storage canisters, and later download and reconstruct the original files.
The current access model is a shared backup workspace: approved users have access to the same workspace key and backups.
Architecture
The frontend uses React and Vite. The backend and storage canisters are written in Motoko.
The current configuration includes:
- A frontend asset canister.
- A backend canister for accounts, permissions, backup manifests, and storage coordination.
- Five storage canisters that store encrypted chunks using Motoko’s persistent Region storage.
The browser uploads encrypted file chunks directly to the storage canisters. An encrypted manifest records the file paths, chunk order, canister IDs, and storage offsets needed for restoration.
One design goal is to widen distribution across additional subnets by adding storage canisters. Upload distribution already uses the number of available canisters, and restoration follows the locations recorded in each manifest. Expanding beyond the current five still requires changes to registration, authorization, and chunk sizing, followed by end-to-end testing. Existing backups are not automatically redistributed.
The storage distribution is striping: different canisters hold different chunks. I have not implemented additional application-level replication or erasure coding.
Encryption and access
Files and manifests are encrypted in the browser using AES-256-GCM, with a fresh random IV for each encryption operation.
Authentication uses Internet Identity. There are three account roles: requester, user, and admin. An administrator approves access, and the frontend uses vetKeys-based identity-based encryption to wrap the shared backup key for the approved user’s principal.
Key rotation and access revocation are areas I still need to improve. Removing a user’s role restricts further API access, but it does not rotate the shared key or revoke data they have already downloaded.
What I’ve implemented
- File and folder selection, including multiple backup sources.
- Client-side encryption and encrypted backup manifests.
- Chunk distribution across five storage canisters.
- Parallel upload lanes, with worker-based encryption where supported.
- Content-based deduplication within an upload.
- Downloading, decrypting, and reconstructing files and folder paths.
- Account approval and role management.
- Logical backup deletion.
- An initial storage compaction mechanism intended to reclaim space occupied by deleted backups for reuse. It relocates active chunks and updates their manifest offsets. The implementation still needs fixes to prevent overwriting unread chunks and to recover safely from interruptions; it does not shrink already allocated stable memory.
Current stage
This is a development project. It has not been independently audited, and I’m not presenting it as a production-ready backup service.
Storage compaction needs corrections to its data-movement and interruption-recovery logic. Provisioning additional storage canisters, managing the shared key lifecycle, and recovering from interrupted operations also need more work and testing.
I’d also like to measure upload and restore performance, cycle costs, and browser memory use with larger datasets.
Feedback I’d appreciate
- Does a shared encrypted backup workspace address a useful need in the ICP ecosystem?
- What would you change about the storage and manifest architecture?
- How would you approach key rotation and access revocation?
- Which failure and recovery scenarios would you test first?
- How could I make the code easier to understand, maintain, and test?
Building this has given me practical experience connecting a frontend, authentication, browser cryptography, Motoko services, and persistent storage into one application. It has also helped me understand how much of a backup system’s design comes down to handling failures and making restoration dependable.
I’m looking for opportunities to contribute to a team and continue learning, including junior software engineering roles or project work involving ICP, Motoko, or frontend development. If this project is relevant to your work, I’d welcome a conversation.
Thanks for taking a look. I’m proud to share this milestone, and I’d appreciate honest technical feedback.