Skip to content

Transfers · 3 min read · Updated

How Resumable Multipart Uploads Work

The engineering behind reliable large-file transfers: how uploads are split into parts, why each part is uploaded under short-lived scoped authorization, and why an interrupted 20 GB upload does not start over.

The problem with one big request#

A single HTTP upload of a 20 GB file has three failure modes built in. If the connection drops at 95%, the whole transfer restarts from zero. If the server connection resets, browsers hold gigabytes in memory or spill them to disk unpredictably. And if the request times out, nobody can tell which bytes actually arrived.

Multipart upload is the industry answer — it is the same mechanism major cloud providers use natively, and it is how LinkPitara transfers work from the browser. Instead of one giant request, the client splits the file into parts and uploads them one at a time.

How the parts flow#

Here is the shape of a well-built resumable transfer, end to end:

  • Initiation. The service is asked to start an upload for a file of a known size, heading for a destination folder. It records the upload session and prepares storage for the incoming parts.
  • Part geometry. The file is divided into parts of a fixed size. The plan — part count, offsets, and checksums — is agreed up front so any party can verify the transfer.
  • Authorized part uploads. Every part is uploaded under a short-lived, narrowly scoped authorization that permits uploading exactly that piece — long-lived storage credentials never live in the browser.
  • Direct transfer. The browser reads each part from the file and sends it straight to storage. The file bytes do not detour through the application server, which keeps transfers fast.
  • Verification. The service reconciles what the storage actually received against what the client reported — storage is the source of truth, not the browser.
  • Completion. Once every part is confirmed, the upload is finalized, the file becomes a real record in your drive, and background processing (like video preparation) takes over.

LinkPitara implements this pattern so that a multi-gigabyte upload behaves predictably: each part either arrived or it did not, and the answer is checked server-side.

What "resume" really means#

An interrupted resumable upload is not a failed one — it is a paused one. The parts that finished are durable; the parts that did not can be retried. When you resume, the client asks which parts still need to be sent and picks up from there instead of starting over.

On LinkPitara, a supported interrupted upload can be recovered for 7 days while the upload session stays valid. The session eventually expires and reserved space is released — an abandoned 15 GB upload should not occupy storage forever. Expired sessions are cleaned up automatically, which is why the recovery window is a policy, not a promise of indefinite storage.

Why this design is also safer#

The same architecture that makes transfers reliable also makes them safer:

  • No long-lived storage credentials ever ship to the browser — part uploads run under short-lived, narrowly scoped authorizations.
  • Upload space is accounted for up front, so concurrent transfers cannot oversubscribe the service.
  • The application server never proxies file bytes, so it cannot retain copies of your files in transit.
  • Every state transition is server-authorized — pausing, resuming, and cancelling are permission-checked actions, not client-side wishes.

Resumability has honest limits: after a force-stop, an OS update, or once the recovery window passes, you may need to re-select the original file to continue. Real transfer engines tell you which case you are in rather than showing a fake progress bar.

Keep reading

Questions about the product? Send a request.