-
-
Dashboard- Watch file transfers as race cars on live lanes speed, pit stops, and telemetry all in one high-speed dashboard.
-
Landing Page- Launch your file races! Choose a project, set network conditions, and start transfers with “Race your files home"
-
Dive into each transfer. Visualize chunk health, retries, and integrity with live controls for pause, resume, or reroute.
-
Track every file’s journey. View retries, checksums, and performance stats — ensuring reliability and accountability.
-
Drag, drop, and configure smart transfers. Set priorities, chunk sizes, encryption, and scheduling in seconds.
Inspiration
Our inspiration came directly from the sponsors, Mphasis Foundation and MoneyGram F1.
We saw two powerful, connected stories in the problem statement:
The Mphasis Mission
The "mobile clinics" and "rural labs" spoke to us.
We imagined a doctor trying to send a large MRI scan to a specialist over a spotty 4G connection.
If that transfer fails at 99%, it's not an IT problem—it could delay critical care.
The MoneyGram F1 Mission
The "racetrack <=> factory" application put the problem into a high-stakes, high-speed context.
We pictured the F1 team, where gigabytes of real-time telemetry must be sent from the trackside during a race.
A dropped packet isn't just an error; it's a lost competitive advantage.
This "last-mile" data problem—whether on a rural road or a high-speed racetrack—became our obsession.
We named our solution Momentum, capturing both the speed of F1 and the forward progress of social impact.
What it does
Momentum is a fully-functional MVP that solves the core problem of unreliable file transfers.
Our system:
- Resumes Broken Transfers – It intelligently "chunks" large files, sends them individually, and resumes a transfer from the exact chunk that failed — never re-sending data.
- Guarantees 100% Data Integrity – It calculates a SHA-256 hash for every chunk before transfer and verifies it on the receiving end. This mathematically guarantees the final reassembled file is bit-for-bit perfect.
- Prioritizes Critical Data – It features a dynamic priority queue. A "Critical" file (like F1 telemetry or a patient's medical scan) will automatically pause any "Low" priority transfers to take all available bandwidth.
- Provides Real-Time Status – A clean, responsive dashboard shows the live status of all transfers, powered by WebSockets for zero-delay updates.
How we built it
We built a robust client-server architecture designed for resilience.
Backend (Python & FastAPI):
We chose FastAPI for its asynchronous performance.
The server manages all transfer jobs, handles the file "chunking" logic, generates SHA-256 hashes, and uses a simple JSON-based "manifest" file to track the pending, sent, and verified state of every single chunk.
Frontend (React):
We built a responsive dashboard in React. It uses react-dropzone for easy drag-and-drop file uploads (with priority settings) and connects to the backend via a native WebSocket API for high-frequency, real-time status updates.
Resilience Protocol:
We designed a custom, application-layer acknowledgment protocol (ACK/NACK).
This allows our application to manage retries and resumption logic itself, rather than relying on the underlying network, which we assume to be unreliable.
Challenges we ran into
Challenge 1: Testing an Unstable Link
Our biggest challenge was simple: How do you test an "unstable link" on a stable hackathon network?
We couldn't just say it was resilient; we had to prove it.
Solution: The Chaos Monkey.
We built a "Chaos Monkey" middleware in our test environment.
This tool intentionally dropped random packets, injected high latency, and even simulated total connection loss for several seconds at a time.
Challenge 2: Robust State Management
If a client disconnects and reconnects, how does the server know exactly which chunks were successfully verified?
Solution: The Transfer Manifest.
The server-side manifest file is the "single source of truth."
When a client reconnects, it "handshakes" with the server, they compare manifests, and the server queues up only the chunks that were marked as pending or sent but never verified.
Accomplishments that we're proud of
It Actually Works.
Our proudest moment was watching our MVP successfully transfer a 500MB test file while our 'Chaos Monkey' was actively dropping 30% of the packets.
The system paused, retried, and resumed flawlessly, reassembling a file with a perfect SHA-256 hash match.The Priority Queue in Action.
We successfully demonstrated a low-priority transfer (e.g., "archive data") automatically pausing to make bandwidth for a new "critical" transfer (e.g., "live telemetry").Building our Own Application-Layer Protocol.
We developed a protocol that handles packet verification and resumption, proving our core concept is sound.Prototyping 'Adaptive Transfer Logic'.
We demonstrated an "adaptive" transfer mode that understands the data itself — treating an F1 telemetry stream (where the newest packet is most important) differently from an MRI scan (where 100% integrity is non-negotiable).
What we learned
This project was a deep dive into data resilience.
We learned that "resilient transfer" is far more complex than just a "retry" button.
The true, robust solution lies in atomic chunking and independent chunk verification.
We also learned that for real-time applications like F1 or telemedicine, a dynamic, pre-emptive priority queue isn't a 'nice-to-have' — it's the single most critical feature.
The data's context (telemetry vs. medical scan) is just as important as the connection quality.
Log in or sign up for Devpost to join the conversation.