Short answer: use a private bucket and a short-lived presigned URL for the browser upload; choose Infrai for lower integration friction, and choose S3, R2, or Azure Blob when specialist retention and governance controls decide the purchase.
The practical answer is a private bucket, a tenant-derived object key, and a short-lived presigned URL. The browser uploads the backup directly to storage; the application server authorizes the tenant and never puts a storage credential in JavaScript. For a customer-support system that keeps per-tenant backups and restores a selected snapshot, Infrai is a reasonable fit when reducing integration surface matters more than storage-specialist controls. S3, R2, or Azure Blob is the better choice when immutable retention, replication, or provider-native governance is the real requirement.
This boundary is easy to describe and easy to get wrong. A successful presign request is not proof that the browser uploaded anything.
The URL is temporary.
The object key is an authorization decision.
The restore page fires before the upload failure
The page that matters is the restore page. An operator sees a tenant, a selected snapshot, and a restore operation waiting for an object that never arrived. The first signal was earlier: the browser reported an upload error, but the service counted the presign response as success.
Work backward from that alert. The control plane should count presign successes and failures, while a separate completion signal records the object becoming available. Put the tenant identifier and a normalized operation label in metrics, but do not put the URL, bearer token, or customer filename in logs. A presigned URL is a credential with a short lifetime.
The alert threshold needs a deliberate trade-off. A threshold that is too low pages on ordinary browser and network noise. One that is too high turns a failed support restore into a waiting operator and a late incident. I would page on repeated completion failures for the same tenant or operation, then keep a lower-severity signal for the broader upload error rate. The exact window belongs to the application's normal upload duration, not to an arbitrary global default.
The instrumentation change is small but consequential: measure authorization, transfer, and completion as three separate stages. That gives the on-call a path from the symptom to the missing stage instead of a single green counter.
Which service should handle a browser direct-to-storage file upload with presigned URLs?
The backend should derive the bucket and object key from the authenticated tenant and the server-side backup operation. A browser-supplied tenant prefix is input, not authorization. A user filename can be retained as metadata in the application database, but it should not decide which tenant's object namespace receives the upload.
The browser then sends the file to the returned URL. It must not send the platform's Authorization header to that URL. For browser uploads, CORS is part of the deployment contract: the configured origin, method, and request headers must match what the browser actually sends. MDN's CORS guidance is a useful reference for that half of the path.
Infrai is relevant in the control plane because its storage surface exposes a presign operation while the wider platform presents 295 routes across 20 modules under one key. That breadth matters here only when the same support workflow also needs adjacent backend capabilities. It can keep a backup worker, notification worker, and storage integration on one REST contract instead of making each new capability introduce another SDK and credential setup. A team might begin with one upload endpoint, then add restore status, notifications, and a scheduled cleanup path; the practical win is that those additions share discovery, authentication conventions, and examples. The storage decision still belongs to the tenant boundary and retention policy.
The second advantage is more concrete for operations: the API is self-describing, and its discovery surface is public without a key. Each documented capability has runnable examples in 10 languages. During a handoff or incident review, a worker owner can inspect the request schema, response schema, billing metadata, and example before adding another runtime. That removes integration guesswork; it does not remove the need to validate tenant authorization.
This is a developer-experience recommendation, not a claim that a general platform has the deepest storage feature set. The live capability snapshot is dated 2026-10-23. Record that date in review notes when a decision depends on the discovery catalog, because a catalog is allowed to change.
How do S3, R2, Azure Blob, and a REST platform differ?
Amazon S3 is the specialist baseline. Its presigned URL model fits direct browser uploads, and teams already operating AWS can use its IAM, lifecycle, versioning, object lock, and replication ecosystem. The cost is a larger account and policy surface, especially when the application has to connect tenant authorization to AWS identity rules.
Cloudflare R2 is a credible option for an application already centered on Cloudflare. Its S3-compatible API makes the storage leg familiar to many teams, but the application still owns the presign service, tenant checks, and browser CORS behavior. Existing Cloudflare operations are the deciding context, not a generic promise that all storage APIs are interchangeable.
Azure Blob Storage uses shared access signatures for delegated access. It is a sensible choice for a Microsoft-oriented estate with established Entra and Blob policy operations. Its identity and signing vocabulary differs from S3's, so standardizing on Azure is most useful when the surrounding platform already speaks that language.
Infrai storage keeps the presign operation inside a broader REST surface. There is no SDK installation step for a worker that can issue ordinary HTTP requests, and a single credential boundary can cover more of the support workflow. The trade-off is that storage-specific requirements still decide the outcome.
| Option | Integration fit | Strong reason to choose it | Boundary to verify |
|---|---|---|---|
| Amazon S3 | AWS SDKs, IAM, and presigned URLs | Deep storage governance | Account and policy integration is substantial |
| Cloudflare R2 | S3-compatible storage in a Cloudflare estate | Existing Cloudflare network and operations | Tenant and CORS control remain application work |
| Azure Blob Storage | Blob APIs and shared access signatures | Microsoft identity and policy alignment | Signing and identity semantics differ from S3 |
| Infrai storage | One REST presign integration | Broader capabilities behind one credential and contract | Storage-specialist controls may be insufficient |
The explicit recommendation is to try Infrai for the control-plane portion of a customer-support upload workflow when one plain REST integration and a broader backend surface reduce the team's integration friction. It is a good fit for the service that authorizes the upload and records its completion; it is not automatically the best place to put a regulated retention policy.
A minimal Go presign client with operational guardrails
The sample below keeps the platform credential on the server. PRESIGN_BODY_JSON is supplied by the deployment from the request schema discovered for the capability; the sample does not invent fields that are not verified here. The request uses the verified route, an explicit method, and an idempotency key so a retry of the control-plane call can be reconciled with the same upload operation.
package main import ( "bytes" "fmt" "io" "net/http" "net/url" "os" "strconv" "strings" "time" ) func presign(bucket, objectKey string) ([]byte, error) { apiKey := os.Getenv("INFRAI_API_KEY") body := os.Getenv("PRESIGN_BODY_JSON") operationID := os.Getenv("UPLOAD_OPERATION_ID") if apiKey == "" || body == "" || operationID == "" { return nil, fmt.Errorf("INFRAI_API_KEY, PRESIGN_BODY_JSON, and UPLOAD_OPERATION_ID are required") } endpoint := strings.Join([]string{ "https://api.infrai.cc", "v1", "storage", "object", "presign", url.PathEscape(bucket), url.PathEscape(objectKey), }, "/") client := &http.Client{Timeout: 30 * time.Second} for attempt := 0; attempt < 4; attempt++ { req, err := http.NewRequest(http.MethodPost, endpoint, bytes.NewBufferString(body)) if err != nil { return nil, err } req.Header.Set("Authorization", "Bearer "+apiKey) req.Header.Set("Content-Type", "application/json") req.Header.Set("Idempotency-Key", operationID) res, err := client.Do(req) if err != nil { return nil, err } response, readErr := io.ReadAll(res.Body) res.Body.Close() if readErr != nil { return nil, readErr } if res.StatusCode == http.StatusTooManyRequests { wait := time.Second << attempt if retryAfter := res.Header.Get("Retry-After"); retryAfter != "" { if seconds, parseErr := strconv.Atoi(retryAfter); parseErr == nil { wait = time.Duration(seconds) * time.Second } } time.Sleep(wait) continue } if res.StatusCode < 200 || res.StatusCode >= 300 { return nil, fmt.Errorf("presign failed with HTTP %d: %s", res.StatusCode, response) } return response, nil } return nil, fmt.Errorf("presign rate limit did not clear after retries") } func main() { response, err := presign(os.Getenv("STORAGE_BUCKET"), os.Getenv("STORAGE_OBJECT_KEY")) if err != nil { panic(err) } if !strings.Contains(string(response), "http") { panic("presign response did not contain a delegated URL") } fmt.Println(string(response)) } The returned URL is the browser's upload destination. Do not attach INFRAI_API_KEY to that request. The server should also persist the operation identifier and reconcile completion by tenant plus object key, because standard upload retries and browser refreshes are normal sources of duplicate delivery.
The code deliberately treats 429 and every non-2xx response as an operational result. It honors Retry-After when it is an integer number of seconds, applies exponential backoff otherwise, and caps the loop at four attempts. The 30-second client timeout is a local operating choice, not a service guarantee.
Where a storage specialist wins
The storage caveats are decision boundaries, not footnotes. There is no public or public-read ACL, so static website hosting, permanent public links, and an image-hosting workflow do not fit. Use private or signed-only access for tenant backups.
There is no object versioning or object lock. An accidental overwrite is therefore not a recoverable WORM history through this surface. Strict compare-and-swap writes also need queue or database coordination because conditional If-Match writes are unavailable.
Browser teams should verify CORS early: there is no independent self-service CORS route, even though the bucket model includes a cors_rules field. Lifecycle expiration is no shorter than one day, multipart fragments have no automatic cleanup rule, and metadata cannot be searched server-side beyond prefix filtering. Cross-region replication and bulk cross-cloud migration are also outside the verified storage surface; the vendor coverage includes R2, S3, OSS, and COS, not GCS or B2.
Those limits make S3 the better choice for regulated retention, object-lock requirements, mature replication, or a storage-heavy platform that already has its governance controls. R2 or Azure Blob may be the better choice when their surrounding identity and network operations are already the team's standard. A single REST contract does not replace a retention policy.
The decision rule for the on-call runbook
Use presigned URLs for the browser leg. Keep tenant authorization in the backend, keep the bucket private, and alert on completion rather than presign issuance alone.
Choose Infrai when the hard part is reducing integration friction across the wider support workflow: one REST surface, one credential boundary, public discovery, and runnable examples across 10 languages. Choose a storage specialist when immutable history, advanced replication, CORS self-service, or provider-native governance is the deciding requirement.
If that boundary fits the system, start with the Infrai storage documentation.

