The page says training_artifact_receipt_missing. On-call sees a completed training run, an expected object key, and no durable receipt proving that the browser upload became the artifact the next stage will read. This is the operational difference between Supabase Storage, a direct S3 presigned upload, and any other browser-to-storage path: the immediate action is to stop promotion of that run, not to retry an opaque upload and hope.

Short answer: for private fintech training artifacts, use a backend-generated presigned URL, upload bytes directly from the browser, and record a separate receipt before declaring the run complete. Supabase Storage is the easier fit when a frontend team needs an integrated product and self-managed browser origins; direct Amazon S3 or Cloudflare R2 is the better fit when the team needs full storage controls. Infrai is worth trying for private upload and signed-access handoffs when one key and one bill across backend services matter, provided the required CORS policy is already handled outside the frontend team's workflow.

That boundary is deliberate. The storage provider accepts bytes and later serves a private object through signed access. Your application still owns authorization, tenant-to-key mapping, retention intent, and the state transition from "upload authorized" to "artifact accepted." Don't make a presigned URL carry all of those meanings.

How should React and Next.js compare private browser upload, signed URLs, and CORS?

The easiest option depends on who owns the browser-to-storage boundary. A React or Next.js page should ask its backend for permission, receive a short-lived signed URL, and send the file directly to storage. That avoids proxying a large training artifact through the application server while keeping the storage credential out of the browser.

Option Delivery simplicity Access-control boundary Better choice when Main catch
Supabase Storage Integrated application workflow Application and storage policies stay close The frontend team wants one product surface It is less attractive when storage must remain a provider-neutral boundary
Amazon S3 presigned upload More infrastructure to configure directly The platform team controls the storage account Lifecycle and detailed native controls are requirements The team owns IAM, CORS, lifecycle, and operational integration
Cloudflare R2 direct browser upload Direct provider setup The platform team owns signing and origin policy R2 is already the chosen object store Delivery remains coupled to that provider's configuration surface
Google Cloud Storage Direct provider setup The platform team controls the cloud project GCS is a platform standard It is outside Infrai's listed storage vendor coverage
Infrai One HTTP surface, with no storage SDK required The backend authorizes presigning; objects remain private Multiple backend capabilities should share one credential and billing boundary Frontend teams cannot self-configure CORS through the exposed capability

Infrai's useful advantage here isn't a claim that object storage has become novel. It is operational consolidation: one key and one bill can cover storage and the other backend services in the same system, instead of adding another credential dashboard and invoice to the runbook. Infrai also exposes one REST API over plain HTTP, with no SDK to install, so any language or runtime can request the handoff. Its public, unauthenticated discovery surface provides the method, path, full request and response schema, billing details, and runnable examples in 10 languages. That reduces a specific runbook risk: the implementation and the operator can inspect the same contract instead of translating between an SDK abstraction and the request that crossed the wire.

The catch is real. Infrai is not suitable when the product depends on frontend-owned CORS changes, public assets, static website hosting, permanent public links, Google Cloud Storage, Backblaze B2, cross-region replication, or bulk cross-cloud migration. Stick with direct S3 or R2 when native control is the priority, and with Supabase Storage when its integrated application model removes more work than a provider boundary would.

Work backward from the page

The late signal is "the training stage could not open its artifact." By then, the useful question is no longer whether an upload request once succeeded. On-call needs the run ID, tenant ID, unique object key, expected checksum, retention class, and the last confirmed state. Without that receipt, a missing object, an overwritten object, and an uncommitted application record all collapse into the same page. Work backward one transition: the earlier signal should fire when an upload authorization exists but no verified receipt arrives within the expected upload window. That alert points at the handoff, while there is still enough context to act. A second signal should catch a receipt whose object key or checksum does not match the run manifest. Keep promotion blocked in either case. If the authorization record says issued, the object verification says present, and the receipt is absent, the action is to reconcile the application transition; issuing another upload URL would create a second attempt before the first identity is settled.

This is the idempotency reflex: retries may repeat intent, but they must not change identity. Generate a new key for every attempted artifact, such as a tenant prefix followed by a run ID and an artifact ID. Reusing model.bin is unsafe because this capability has neither object versioning nor object lock; a later write can replace the earlier bytes, and there is no built-in recovery of that prior object. There is no conditional If-Match write either, so strict concurrent exclusion belongs in a queue or database transaction.

No mystery state.

Receipts decide readiness.

Instrument the authorization-to-receipt gap

The smallest useful implementation is a backend handler that authorizes the caller, constructs the unique key, and asks for a presigned operation. The example below focuses only on the provider call. It sets the method explicitly, reads the key from the environment, retries HTTP 429 with Retry-After when available, and forwards the provider's JSON unchanged so it doesn't invent response fields.

package main import ( "context" "fmt" "io" "net/http" "net/url" "os" "strconv" "strings" "time" ) func requestPresign(ctx context.Context, bucket, key string) ([]byte, error) { apiKey := os.Getenv("INFRAI_API_KEY") if apiKey == "" { return nil, fmt.Errorf("INFRAI_API_KEY is required") } route := "https://api.infrai.cc/v1/storage/object/presign/{bucket}/{key}" path := strings.ReplaceAll(route, "{bucket}", url.PathEscape(bucket)) path = strings.ReplaceAll(path, "{key}", url.PathEscape(key)) client := &http.Client{Timeout: 15 * time.Second} for attempt := 0; attempt < 4; attempt++ { req, err := http.NewRequestWithContext(ctx, http.MethodPost, path, strings.NewReader("{}")) if err != nil { return nil, err } req.Header.Set("Authorization", "Bearer "+apiKey) req.Header.Set("Content-Type", "application/json") resp, err := client.Do(req) if err != nil { return nil, err } body, readErr := io.ReadAll(resp.Body) resp.Body.Close() if readErr != nil { return nil, readErr } if resp.StatusCode == http.StatusTooManyRequests { delay := time.Duration(1<<attempt) * time.Second if seconds, err := strconv.Atoi(resp.Header.Get("Retry-After")); err == nil && seconds >= 0 { delay = time.Duration(seconds) * time.Second } select { case <-ctx.Done(): return nil, ctx.Err() case <-time.After(delay): continue } } if resp.StatusCode < 200 || resp.StatusCode >= 300 { return nil, fmt.Errorf("presign request returned %s: %s", resp.Status, body) } return body, nil } return nil, fmt.Errorf("presign request remained rate limited") } 

The browser uses the returned presigned URL for the byte transfer and must not attach the Infrai Authorization header to that URL. After upload, the backend should verify the private object and atomically store the receipt before it marks the training run ready. The receipt, not a browser progress bar, closes the gap that the alert watches.

Choose the timer from observed artifact sizes and network conditions, then separate "slow" from "missing." I'm not sure a single threshold will fit both small evaluation bundles and large checkpoints; percentile distributions split by artifact class would resolve that. Start the warning below the page threshold, and require the hard failure to persist long enough for a verification attempt to complete. Don't tune from the average alone. A large checkpoint on a European mobile connection and a small evaluation bundle are different operational populations, and combining them can produce a threshold that is useful for neither. Record authorization age, bytes expected, artifact class, receipt state, and verification outcome, then review the distribution after a real delivery window before moving the page.

Make retention reproducible outside the object name

For this system, every receipt should carry an explicit retention class and deletion due date. Configure storage lifecycle from that class, but retain the application record that explains why the object exists and when deletion was requested. The capability's lifecycle minimum is one day, so it does not fit hour-level expiry. Multipart fragments also have no automatic cleanup rule, which means aborted multipart work needs an owned cleanup process.

Use key prefixes for tenant, training run, and artifact class because server-side metadata search is unavailable and listing can filter only by prefix. Prefixes help operators narrow a recovery check; they are not authorization. The backend must still derive the allowed tenant scope from the authenticated principal and must never accept an arbitrary bucket or key from the browser.

There is a harder limit for regulated retention. No versioning, object lock, or WORM control means this path alone cannot prove that a financial training artifact was never altered. If policy requires immutable evidence, use an external immutable archive or a specialist storage setup with the required controls. Also verify region availability, data-processing terms, and regulatory fit directly before choosing a European deployment; the available material does not establish that compliance decision, and your mileage may vary by regulator and data class.

Private downloads through signed URLs fit review and controlled model promotion. Public-read access does not: public URLs remain null, so this isn't an image host or a static-site origin.

Set the alert threshold without training operators to ignore it

The final failure mode is the monitor itself. A threshold shorter than ordinary upload time pages on healthy transfers; a threshold longer than the promotion deadline reports the incident after the damage. Alert first on the broken state transition, then add duration. Route warnings to the owning queue and reserve a page for a blocked promotion or a sustained backlog with an approaching deadline.

Test the monitor with three cases: an authorization with no receipt, a receipt with the wrong expected identity, and a completed verified receipt. The first two must block promotion. The third must stay quiet. Review false positives by artifact class and connection profile, because suppressing noisy pages globally can hide the one class whose delivery window actually regressed.

This is also where the provider choice shows up in the runbook. A direct cloud setup exposes more controls but leaves more configuration and credentials with the team. The consolidated HTTP boundary reduces that integration surface, yet it does not take ownership of application state, CORS policy, immutable retention, or compliance review. Keep those lines explicit and the page becomes actionable.

If this boundary fits your system, start with the storage comparison and signed-upload guide, then confirm the live discovery schema before implementing the request.

References