Transfer History
Transfer Queue
Settings
Settings Feature
Dark Theme Transfer Speed Graph
Transfer History Queue
Transfer Speed Graph
Dark Theme Home Screen
Home Screen

Inspiration

When working on real-world projects with large media files and critical data, I constantly ran into one issue — unstable networks. Especially in rural regions, labs, and mobile setups, file transfers fail, hang, or corrupt halfway through.

Cloud drives and email services? Too slow, unreliable, and insecure.

So I built Smart File Transfer (SFT) — a system designed to never lose progress, stay transparent, and remain reliable even when the internet isn’t. It’s made for real-world chaos, not perfect Wi-Fi conditions.

What it does

SFT (Smart File Transfer) is a resilient, real-time, and secure file transfer system designed to work even in weak or unstable networks. It breaks large files into verifiable chunks, encrypts them for security, and ensures transfers can resume seamlessly after any interruption.

Core Features: AES-128 encryption for data privacy Real-time progress, speed, and ETA tracking using WebSockets Resumable uploads and downloads (no restarts needed) Priority-based queue system (0–10 scale) Batch and bulk uploads for enterprise use Pause, resume, or cancel transfers anytime Live analytics API with stats per user/client REST + WebSocket APIs for easy integration

How we built it

Tech Stack:

Language: Python 3.8+ Framework: Flask Protocols: HTTP, WebSockets (Socket.IO) Security: AES-128 (EAX mode), SHA-256 integrity checks (PyCryptodome) Storage: Local/Server disk (cloud-ready) Testing Tools: VS Code, Curl, and a custom CLI client

Client (CLI / Web UI) ↓ Flask Backend (REST + WebSocket) ↓ Chunk Manager + Priority Queue ↓ Local / Cloud Storage

How it works

Chunked Uploads: Files are split into smaller chunks and verified via SHA-256. Retry Logic: Failed chunks are automatically retried using exponential backoff. Resume Capability: Transfers restart from the last verified chunk, not from zero. WebSocket Updates: The backend broadcasts real-time progress and speed to clients. Encryption Layer: AES-128 EAX ensures end-to-end data security.

Upload with encryption and priority:

         -->       python client.py upload secret.pdf --encrypt --priority 8

Batch upload

         -->       python client.py upload docs/*.pdf --batch --priority 10

Fetch live stats

         -->       curl http://localhost:8080/stats

Challenges we ran into

Concurrency & Thread Safety: Managing multiple simultaneous uploads required careful thread synchronization. One missing lock corrupted transfer stats — solved using Python’s threading locks.

File Integrity Failures: Handling corrupted chunks mid-transfer was tricky. We implemented checksum validation and recovery logic.

Resilience vs Performance Trade-offs: High verification frequency improved safety but increased CPU load. Solution: Dynamic chunk sizing based on network response times.

Network Testing: We simulated real-world dropouts by cutting off Wi-Fi mid-upload to ensure stability and recovery.

Feature Control & Documentation: Continuous feature additions risked API instability. Solved by maintaining strict Swagger API contracts.

Accomplishments that we're proud of:

Built a 100% resumable file transfer backend from scratch. Achieved real-time tracking via WebSockets without polling. Integrated AES-128 encryption with automatic decryption on download. Designed a persistent priority queue system that survives restarts. Achieved complete end-to-end testing for all API endpoints. Created a CLI client that works reliably across unstable connections. Delivered a production-ready, modular, and cloud-compatible backend.

What we learned:

Asynchronous Programming: How to handle concurrency, locks, and non-blocking I/O. Security in Practice: Proper use of AES and SHA to prevent tampering or data leaks. API Contracts: Consistency between backend and frontend saves hours of debugging. Network Adaptation: Designing for 2G/3G-grade networks taught us adaptive retry logic. User-Centric Design: Simple controls like pause/resume and progress transparency greatly improve UX.

What's next for SFT(Smart File Transfer)

Short-Term Goals:

Add deduplication and compression for faster uploads. Build a React + Tailwind dashboard for visual tracking. Add multi-cloud support (AWS S3, GCP, Azure). Implement user-level authentication and access control.

Long-Term Vision:

SFT will evolve into an open-source backbone for file reliability — a tool developers can trust to move critical data even under poor connectivity.

Dream Milestone:

A peer-to-peer + cloud hybrid system that syncs across multiple devices automatically, with full encryption and audit trails.