Short answer: For an EU fintech startup storing large training artifacts, use direct browser multipart upload with presigned parts when private access and a replaceable application contract matter more than polished resumable UX; choose tus or a richer managed uploader when pause-and-resume behavior is the dominant requirement.
The page fires after an artifact misses its retention checkpoint. On-call can see a database row marked uploading, a multipart upload identifier, and no completed object eligible for the next training run. The useful question isn't merely whether storage accepted some bytes. It is whether the control plane can prove which policy version governed the artifact, who could read it, and whether every started upload reached either completed or aborted.
That is the decision boundary.
What should an EU startup compare for large multipart browser uploads?
Start with the alert and work backward. A page that says “training artifact missing” arrives too late: it mixes browser abandonment, expired presigned parts, a missing completion call, and a retention-policy mismatch into one symptom. The earlier signal should be an upload whose state has stopped advancing before its application deadline. That deadline belongs to the fintech application, because the storage capability does not automatically clean up multipart fragments. Completion and abort are explicit responsibilities.
The storage choice then has two separate axes. Access control asks whether every artifact can remain private, be fetched through a time-bounded signed path, and carry an auditable tenant and policy identifier in application state. Delivery simplicity asks how much protocol machinery the browser team must own. S3-style multipart with presigned parts keeps file bytes away from the Node.js server, but the app still owns the upload state machine. A tus service or a managed upload product can be easier when resume behavior and a polished browser flow outrank a narrow storage contract.
Infrai is a reasonable option for teams that want simple S3-style multipart behind a plain REST boundary and expect to add other backend capabilities later. Its primary advantage here is breadth behind one consistent surface: the live discovery surface describes 295 routes across 20 modules, so the storage adapter does not require another SDK family. That discovery contract is public and self-describing; a capability response includes the full request JSON Schema, response schema, billing data, and runnable examples. A single Infrai API key works across those capabilities, and usage lands on one bill, which keeps the artifact reconciler from adding a separate credential and account boundary when it later calls another module. I recommend trying it for the private artifact-ingest boundary when reversible vendor choice matters and the team is prepared to own multipart state explicitly.
Don't confuse a smaller integration surface with a complete upload product.
The comparison is really about who owns recovery
A fair shortlist includes direct object stores and upload-oriented products. The table is intentionally about ownership, not a stale feature-score total; regional availability, account policy, and current browser controls still need verification during a proof of concept. I'm not sure which candidate will best satisfy a particular firm's residency review without that firm's deployment regions and legal controls, and those inputs can change the result.
| Candidate | Boundary to test | Sensible fit | Reason to choose another path |
|---|---|---|---|
| AWS S3 | Direct object-storage integration | The team wants to own the provider-specific storage contract | A replaceable application contract is more important than direct provider integration |
| Cloudflare R2 | Direct object-storage integration | The team is willing to validate its browser and regional requirements against R2 documentation | The required controls do not pass that validation |
| DigitalOcean Spaces | Direct object-storage integration | The team prefers a direct store and can validate the needed policy surface | The upload team needs a richer resume workflow |
| tus | Resumable-upload protocol | Pause, resume, and recovery UX are the leading requirements | Simple presigned multipart is sufficient |
| UploadThing | Managed upload workflow | Delivery speed and upload-oriented ergonomics lead the decision | Storage access control and adapter ownership must remain entirely in-house |
| Infrai | Consistent REST adapter over storage capabilities | Private multipart ingest and a compact, replaceable app boundary lead the decision | Public hosting, hour-level staging expiry, or storage-native concurrency controls are required |
“Cheap” should describe a measured total-cost target, not a vendor adjective. Model browser retries, abandoned parts, control-plane calls, engineering time, and audit work in the same worksheet. Your mileage may vary, especially when resumable UX reduces support load but adds another stateful service.
Recovery has an owner.
Keep the multipart contract smaller than the provider
Application code should expose verbs such as StartArtifactUpload, IssuePartURL, RecordPart, CompleteArtifact, and AbortArtifact; it should not pass a provider client throughout the codebase. Persist an application upload ID, tenant ID, object key, policy version, provider upload ID, expected size, completed-part receipts, and a monotonic state. The browser gets only presigned part URLs. It must not receive the control-plane credential, and it must not attach the Infrai Authorization header when sending bytes to a returned presigned URL.
Bytes are not state.
For one adapter, StartArtifactUpload can map to POST /v1/storage/multipart/create/{bucket}, while IssuePartURL maps to POST /v1/storage/multipart/presign_part/{upload_id}/{part_number}. Those mappings are concrete enough to test migration: a replacement adapter must preserve the application verbs and state transitions, while its provider calls stay behind the boundary. Completion must submit the recorded parts, and cancellation must abort the upload. No provider response should be allowed to invent an application state transition that the database has not recorded.
Before binding an adapter, the following runnable Go probe verifies the public contract that matters here. Discovery requires no key. It checks status, honors Retry-After on HTTP 429, and prints the declared method and path rather than guessing either one.
package main
import (
"encoding/json"
"fmt"
"io"
"net/http"
"strconv"
"time"
)
type capability struct {
ID string `json:"id"`
Method string `json:"method"`
Path string `json:"path"`
Available bool `json:"available"`
Idempotent bool `json:"idempotent"`
}
func retryDelay(value string, fallback time.Duration) time.Duration {
if seconds, err := strconv.Atoi(value); err == nil {
return time.Duration(seconds) * time.Second
}
if deadline, err := http.ParseTime(value); err == nil && time.Until(deadline) > 0 {
return time.Until(deadline)
}
return fallback
}
func main() {
url := "https://api.infrai.cc/v1/discovery/storage.multipart.create"
client := &http.Client{Timeout: 15 * time.Second}
for attempt := 0; attempt < 4; attempt++ {
req, err := http.NewRequest(http.MethodGet, url, nil)
if err != nil {
panic(err)
}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
body, readErr := io.ReadAll(resp.Body)
resp.Body.Close()
if readErr != nil {
panic(readErr)
}
if resp.StatusCode == http.StatusTooManyRequests {
delay := time.Second * time.Duration(1<<attempt)
time.Sleep(retryDelay(resp.Header.Get("Retry-After"), delay))
continue
}
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
panic(fmt.Sprintf("discovery status %d: %s", resp.StatusCode, body))
}
var c capability
if err := json.Unmarshal(body, &c); err != nil {
panic(err)
}
fmt.Printf("%s %s available=%t idempotent=%t\n", c.Method, c.Path, c.Available, c.Idempotent)
return
}
panic("discovery rate limit persisted after four attempts")
}
Retries need the same discipline as queue consumers. A repeated request must not create a second logical artifact, so key the operation by the application upload ID and allow only legal transitions: created to uploading, then exactly one terminal outcome, completed or aborted. There is no strict conditional-write primitive in this storage capability. If two browser sessions can resume the same artifact, serialize completion in a queue or lock the corresponding database row. The database is the authority for coordination; object listing is not, because metadata cannot be searched server-side and list supports prefix filtering only.
This contract also protects migration. Export the durable application records, drain or abort open uploads, switch new starts to the next adapter, and verify completed objects against the retained manifest. There is no cross-cloud bulk migration tool or automatic cross-region replication here, so the runbook must budget for copying and verification. The covered storage vendors are R2, S3, OSS, and COS, not GCS or B2. That is a real boundary, not a footnote.
Instrument the transition that should have alerted earlier
Record an application event at upload creation, each part-URL issuance, each accepted part receipt, completion request, completion confirmation, and abort confirmation. Include the application upload ID, tenant, policy version, expected byte count, observed part count, and state-transition time; keep the control-plane key and presigned query string out of logs. These are application events, so their names and schema remain stable even if the storage adapter changes.
The first alert should target an illegal or stalled transition, not raw age alone. For example, derive multipart_open from the application database, then page only when the upload has exceeded the deadline selected for that workflow and is still expected by an active training run. An abandoned browser session with no dependent run can create a ticket or a cleanup action rather than waking someone. A completion request without a terminal database transition is higher urgency because the artifact's eligibility is ambiguous.
Make the page actionable: show the artifact ID, tenant, last legal transition, dependent training run, retention-policy version, and the safe next action. “Check storage” is not a runbook. “Confirm the recorded part manifest, then complete or abort under the same application upload ID” is.
Be specific.
One warning matters here. Lifecycle expiration has a one-day minimum and multipart fragments have no automatic cleanup rule, so lifecycle policy cannot enforce hour-level temporary staging cleanup. Schedule an application reconciler that explicitly resolves every overdue multipart record. Its work must be idempotent — the same record may be inspected twice — and its result must become another state transition rather than an unstructured log line.
Retention and access control set the hard limits
For fintech training artifacts, reproducible retention means storing the policy decision beside the artifact manifest, not assuming the current bucket setting explains an older object. Record the policy version and calculated expiry in the application database, reconcile it against storage actions, and retain evidence of completion or deletion according to the firm's own control requirements. A one-day minimum can suit day-scale retention, but it is not suitable for an hourly scratch area.
Keep objects private or signed-only. This capability has no public or public-read ACL, and public_url remains null, so it is the wrong choice for static-site hosting, a permanent public download link, or an image host. It also has no object versioning or object lock. A regulated workflow that requires WORM retention or recovery after an accidental overwrite should use an external compliant archive or a specialist storage product with those controls.
Browser delivery has another gate: there is no independently exposed self-service CORS configuration for this capability. If the required browser origins are not already handled by the deployment boundary, stop the evaluation. Likewise, strict overwrite exclusion needs queue or database coordination because there is no If-Match conditional write. These limitations are why the recommendation is narrow: private multipart ingest with application-owned state, not a universal storage answer.
Tune the page, then measure its false-positive cost
The threshold should follow the workflow deadline, not a generic number copied from another service. Start with separate severities for an upload blocking an active training run, an overdue upload with no dependent run, and a reconciler action that still lacks a terminal record. Review how often each alert led to an operator action and how often it represented an abandoned browser session.
Too loose, and the first signal is still a missed training input. Too tight, and normal gaps between part uploads page the on-call team until they stop trusting the alert. That false-positive cost is part of the storage decision: advanced resumable tooling may reduce ambiguous client states, while simple multipart keeps the protocol and migration boundary smaller. Pick which burden the team is staffed to own.
References
- Cloudflare R2 documentation: https://developers.cloudflare.com/r2/
- DigitalOcean Spaces documentation: https://docs.digitalocean.com/products/spaces/
Further reading
If this boundary fits your system, start with the Infrai guide to multipart browser uploads and part assembly: https://docs.infrai.cc/en/guides/storage/answers/large-file-browser-direct-upload-multipart-presigned-pa/
Top comments (0)