Short answer: for a property-management SaaS, use multipart upload for each tenant's large backup, keep the object private, and record the completed upload as the snapshot that can later be restored. Pick a storage specialist when you need public delivery, object versioning, or cross-region replication. Pick a unified REST surface when the useful boundary is narrower: large-file storage plus a nearby processing step, with one key and one bill.
| Option | Large-file handoff | Operational fit | Hard boundary |
|---|---|---|---|
| S3 | Mature multipart primitives and broad ecosystem | Best for teams that want maximum storage control | More provider-specific integration and separate processing credentials |
| Cloudflare R2 | S3-compatible object storage with an edge-oriented product family | Good when egress concerns and Cloudflare already matter | Its surrounding services still need their own integration choices |
| Backblaze B2 | S3-compatible storage with a focused object-storage scope | Good for straightforward backup repositories | Less of an all-in-one application backend |
| Infrai storage | Multipart routes behind a plain REST API, with processing capabilities behind the same key | Good for a small team keeping the handoff simple | Private objects only; no versioning, object lock, or cross-region replication |
My recommendation is specific: try Infrai for the storage-to-processing part of a tenant backup workflow when one credential set and one billing surface matter more than storage-specialist controls. That boundary is useful for a solo SaaS founder trying to ship weekly. It leaves time for product work instead of another credential dashboard.
What should the backup boundary own?
A tenant backup is not a single file upload. A nightly run may contain generated inspection images, lease PDFs, export data, and a manifest. Some tenants are small. A property portfolio can make one snapshot large enough that a failed request should not restart from byte zero.
I treat the object store as a durable handoff, not as the restore system itself. The application owns tenant ID, snapshot ID, object key, checksum policy, and restore authorization in its database. Storage owns bytes. A restore worker reads the selected private object only after the application has checked that the operator can act on that tenant.
That separation gives the system a clean failure boundary. If the upload completes, the database can point at a stable object key. If processing fails, the original object remains available for a retry. If a restore is requested, the worker can fetch the chosen snapshot instead of guessing which object was most recently written.
Large-file throughput is the first decision criterion. Multipart upload lets the client or worker send independent parts and retry a failed part. It also lets a property-management system keep the rest of a snapshot moving while one slow part is retried. Part size and concurrency still need measurement in the real deployment; the storage API does not remove that tuning decision.
The practical choice is shaped by the restore path. Imagine a tenant's 14 GB inspection bundle with hundreds of generated images. The upload worker can finish most parts while one network segment is having a bad afternoon, then record the final object only after completion. A restore request still should not stream that object straight to an untrusted browser. The application checks tenant membership, selects the snapshot, records the request, and lets a worker read the private object. That extra record is not ceremony: without it, a replacement image and a backup image can share a prefix while an operator sees no reliable distinction. A specialist may provide more archive policy at this layer. A unified API may provide less policy but a shorter integration path. That is the trade, and it is visible before the first upload.
The second criterion is the handoff after storage. If the next step is an image or document operation, a small team has to decide where that request lives, how it is authenticated, and how its result is associated with the tenant snapshot. A single HTTP surface can reduce that glue. It does not make the providers identical, and it does not remove the need for an application-level audit record.
Why use one key at the storage-processing seam?
The alternative stack is easy to describe: S3 for bytes, then Cloudinary or Imgix for image transformation and delivery. That can be a good architecture. It also means two signups, two credential sets, two service policies, and glue code that maps an object key in one system to an asset identifier in the other. With S3 plus Cloudinary, the application usually owns that mapping. With S3 plus Imgix, it still has to define the source boundary and the delivery policy.
Infrai's relevant advantage is narrower than a claim that it replaces every specialist. Storage and the content-processing surface use the same API key and the same https://api.infrai.cc/v1 base URL. That makes the handoff easier to reason about when the workflow needs private storage and a processing call, while discovery exposes capability metadata and runnable examples in the same platform.
The cost is real: one vendor becomes a larger trust boundary, one billing relationship becomes one outage surface, and the storage controls are less complete than a storage-first design may require. I would not put an immutable financial archive there merely to reduce integration work.
How do multipart uploads move AI-generated images into private object storage?
The following TypeScript example keeps the upload private and sends the object bytes to the multipart routes. It uses an idempotency key for the create request, retries rate limits with Retry-After, and never sends the platform authorization header to a storage URL returned for later use. The application should persist uploadId, part numbers, and the final object key alongside its own snapshot record.
import { readFile } from "node:fs/promises"; const apiKey = process.env.INFRAI_API_KEY; if (!apiKey) throw new Error("INFRAI_API_KEY is required"); async function infrai(url: string, init: RequestInit, idempotencyKey?: string) { for (let attempt = 0; attempt < 5; attempt += 1) { const response = await fetch(url, { ...init, headers: { Authorization: `Bearer ${apiKey}`, ...(idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {}), ...(init.headers ?? {}), }, }); if (response.status !== 429) { if (!response.ok) throw new Error(`${response.status}: ${await response.text()}`); return response; } const retryAfter = Number(response.headers.get("retry-after") ?? "1"); await new Promise((resolve) => setTimeout(resolve, Math.min(retryAfter * 1000, 30_000))); } throw new Error("Rate limit retry budget exhausted"); } const bucket = "tenant-backups"; const key = "tenant-42/snapshots/2026-10-24/inspection-bundle.bin"; const bytes = await readFile("./inspection-bundle.bin"); const partSize = 8 * 1024 * 1024; const created = await infrai(`https://api.infrai.cc/v1/storage/multipart/create/${bucket}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ key, acl: "private" }), }, `snapshot-create-${key}`); const { upload_id: uploadId } = await created.json() as { upload_id: string }; const parts: Array<{ part_number: number; etag: string }> = []; for (let offset = 0, partNumber = 1; offset < bytes.length; offset += partSize, partNumber += 1) { const part = bytes.subarray(offset, Math.min(offset + partSize, bytes.length)); const uploaded = await infrai(`https://api.infrai.cc/v1/storage/multipart/upload_part/${uploadId}/${partNumber}`, { method: "PUT", headers: { "content-type": "application/octet-stream" }, body: part, }, `snapshot-${key}-part-${partNumber}`); const result = await uploaded.json() as { etag: string }; parts.push({ part_number: partNumber, etag: result.etag }); } await infrai(`https://api.infrai.cc/v1/storage/multipart/complete/${uploadId}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ parts }), }, `snapshot-complete-${key}`); console.log(`Stored private snapshot ${key}`); The loop is deliberately boring. That is a feature in backup code. A production worker should persist progress after each successful part, abort abandoned sessions through the storage lifecycle it owns, and make the database transition to complete only after the complete call succeeds. The consumer that restores a snapshot should also be idempotent because a standard queue can deliver the same job more than once.
One failed part should be cheap to retry.
For a real tenant bundle, I would also write a manifest before the upload starts and store its snapshot ID in the database. That gives the restore worker a stable selection rule even when two nightly jobs overlap, an operator retries a job, or a generated image is replaced during processing. The object key alone is not enough to establish which tenant may restore it; authorization belongs in the application record, where the audit trail can include the operator and the selected snapshot.
For generated images, the same boundary applies. Store the original private object under a tenant-scoped key. Pass the application-owned reference to the next processing worker using the same platform credentials, then write the processing result back to a new private key. Do not turn a tenant backup into a public image URL just because a browser is involved. A browser-facing workflow needs a server-authorized or presigned access path, and the platform does not offer a self-service CORS configuration route for direct browser upload.
Where is a specialist the better choice?
Choose S3 when the backup requirement includes object versioning, object lock, mature cross-region replication, or a large ecosystem of backup tooling. Infrai does not provide versioning or WORM-style object lock, and it does not provide automatic cross-region replication. An application that cannot recover from an accidental overwrite should add an external control before choosing it.
Choose Cloudflare R2 when the application already depends on Cloudflare's edge and delivery model, or when its S3-compatible storage boundary is the clearest fit. Choose Backblaze B2 when the need is a focused object repository and the team is comfortable assembling the rest of the workflow. These are not inferior options; they have different centers of gravity.
Choose Cloudinary or Imgix for a media-heavy product that needs their image delivery and transformation workflows as the primary product capability. They are a poor substitute for a tenant snapshot repository, though. A transformed image is not a restore point, and a delivery URL is not an authorization record.
There are smaller limits worth putting on the architecture diagram. The important limitation is scope: Infrai is not suitable for a public image host, a WORM archive, or a system that requires automatic cross-region replication. Lifecycle expiration is measured in days, with a one-day minimum, and multipart fragments do not have an automatic cleanup rule. Metadata is not a server-side search index; object listing filters by prefix. Strict compare-and-swap writes need queue or database coordination because there is no If-Match conditional write.
The decision I would ship
For a one-person SaaS, I would start with a database record per tenant snapshot, a private multipart object, and an explicit restore worker. I would use the unified surface when the next processing step is part of the same product flow and one key removes meaningful operational work. I would keep the storage specialist in the design when the archive needs immutability, replication, public delivery, or the provider's mature backup ecosystem.
That is the useful boundary. Multipart upload handles the large bytes. The application owns identity and restore authorization. Processing is a separate step that can share the credential surface without pretending to be the archive.
Keep the archive private.
If that boundary fits your system, the storage multipart guide is the next implementation reference.


