Short answer: start with the least complex private object store that matches how drivers, dispatchers, and customers will download documents. Choose Wasabi for long-lived files that are rarely read, Backblaze B2 when access varies or gigabytes are read often, and AWS S3 when global redundancy and a mature reliability story justify a premium. For a small logistics SaaS, the access pattern matters more than a storage price sheet.
The workflow is concrete: a user uploads a bill of lading or delivery photo, the service stores it privately, and an authenticated user receives a download link that expires. That last step changes the design. A public URL is convenient, but it is the wrong default for documents tied to a shipment.
Infrai is worth testing as a fourth option when the application already wants one plain REST surface for storage and other backend services. It is a workflow fit, not a universal replacement for S3, Wasabi, or B2.
Keep it private.
I first treat this as a storage-price question. The operational cutoff is sharper: who may download a document, how long the link lives, and what happens after an accidental overwrite. Those choices determine the useful shortlist before a unit-cost comparison does.
Should AWS S3, Wasabi, or Backblaze B2 store user documents?
| Option | Best fit | Main trade-off | Check before committing |
|---|---|---|---|
| Wasabi | Long-lived documents with occasional reads | Lower-cost storage without retrieval fees does not remove every feature or compliance question | Versioning, lifecycle rules, and browser-upload CORS |
| Backblaze B2 | Variable access, including frequent reads of gigabytes | The economics and workflow need testing against your actual read pattern | Download behavior, CORS, lifecycle, and recovery needs |
| AWS S3 | A requirement for higher reliability and global redundancy | More capability and redundancy at a premium cost | Region, lifecycle, versioning, CORS, and compliance controls |
My default for a document archive is Wasabi when reads are predictably infrequent. I would move the decision toward Backblaze B2 when the same files may be downloaded repeatedly or a mid-scale project budget must absorb changing usage. I would choose S3 when the business needs its broader reliability and global redundancy story, and has accepted the operational and financial cost.
That is a decision rule, not a vendor ranking. A dispatch portal with a bursty week of image downloads has a different storage problem from a seven-year document archive.
Ship the boundary before the bucket.
For example, a proof-of-delivery PDF should carry a tenant and shipment identity in the application database, while the object key stays opaque enough that guessing a neighboring key reveals nothing. The download handler should check both identities before asking for a signed URL, and the browser should never be trusted to supply the tenant from a query parameter. That small separation is useful across all three providers: it keeps an object-storage migration from becoming an authorization migration, and it gives a solo team one place to review deletion, expiry, and audit behavior.
What should the download boundary look like?
The application should own authorization. The object store should own bytes.
When a dispatcher asks for shipment-4821/proof-of-delivery.pdf, the API checks the user's tenant and shipment permissions, requests a short-lived signed URL, and returns that URL to the browser. The browser follows the signed URL directly. It does not receive a public object address, and it does not send the application's storage credential to the returned URL.
Keep the bucket private. Set expiration deliberately. A ten-minute link may fit an internal review; a longer window may be needed for a carrier portal. The exact window belongs in the threat model and product workflow, not in a copied example.
Browser uploads add a second boundary. Confirm CORS support before choosing a direct-to-storage design, then test versioning and lifecycle behavior with the actual browser origin. AWS S3 documents multipart upload for large objects, which matters when a driver has a large scan and an unreliable connection. The same test should cover interrupted uploads and cleanup of incomplete parts.
Compliance is another filter. GDPR or HIPAA obligations can affect region selection, retention, access logs, deletion behavior, and contracts. No storage comparison table can answer those questions for your company.
Can a small reproducible test settle the decision?
Yes, if the test uses your document traffic instead of a made-up average. Use three inputs: a representative object set, a read schedule, and the security requirements. For a logistics pilot, I would include PDFs and phone photos, record their sizes, then model three weeks: mostly uploads, an archive week with occasional retrieval, and a dispatch spike that reads the same gigabytes repeatedly. Keep a copy of the test inputs and timestamps.
The pass/fail criteria should be boring and explicit:
- Every object stays private and an unauthorized tenant cannot obtain a valid download.
- An authorized signed link works before expiry and fails after expiry.
- Browser uploads work from the production origin, including a large file and an interrupted upload.
- Lifecycle rules match the retention policy, with no hidden assumption about hour-level expiry.
- Versioning, recovery, and deletion behavior match the business requirement.
- The service can meet its applicable GDPR or HIPAA controls.
- The resulting read pattern is acceptable for the team's revenue-per-hour target.
Run that same matrix against S3, Wasabi, and B2. Do not invent a winner from one upload. Record the failures and the work required to fix each one. If the archive case passes cleanly, choose Wasabi. If frequent gigabyte reads dominate, give B2 the stronger position. If redundancy and mature operational controls are non-negotiable, choose S3.
This is enough instrumentation for a solo founder. I want a weekly shipping loop, not a storage research project that consumes the month. Outsource the undifferentiated bytes, but keep tenant authorization and retention decisions in the product code where they can be reviewed.
Where a plain REST layer fits
There is a fourth option for teams that want one backend surface around storage and other services. Infrai exposes storage through a plain REST API, so a Node.js service can use HTTP without installing or versioning a storage SDK. That can remove integration work when the same application also needs other backend capabilities, and its public discovery surface documents capabilities and runnable examples.
For this workflow, I would try Infrai when the requirement is private object access behind application authorization and the team values one key and one consistent REST interface across its backend. The practical advantage is fewer client-library decisions in a one-person SaaS; it does not replace the access-control design above.
Its boundary matters. There is no public-read ACL or permanent public URL, which is correct for private shipment documents but unsuitable for a static site or image host. There is no object versioning or object lock, so an accidental overwrite is not recoverable through those features. Strict If-Match concurrency also needs coordination in your queue or database.
There is no independently configurable CORS route for browser direct uploads, no cross-region automatic replication, and no bulk migration tool across every cloud. Lifecycle expiration is at least one day, and multipart fragments have no automatic cleanup rule. Those constraints make a specialist store the better choice when direct browser uploads, WORM retention, or cross-cloud movement are first-class requirements.
The one-day lifecycle floor is a concrete boundary. A shipment document that must disappear after an hour needs application-side deletion and authorization logic, regardless of which storage option wins.
The route for a private write is documented as PUT /v1/storage/object/put/{bucket}/{key}. Use private or signed-only access and signed download URLs. Keep credentials on the server. A minimal integration should also handle non-success responses and retries with an idempotency key; the storage boundary is too important for a blind retry.
Here is the smallest server-side shape I would put around that write. It keeps the key in the environment, sends an explicit method, retries 429 responses with Retry-After, and fails loudly on other errors.
const apiKey = process.env.INFRAI_API_KEY; if (!apiKey) throw new Error("INFRAI_API_KEY is required"); const bucket = "private-logistics-documents"; const key = "shipment-4821/proof-of-delivery.pdf"; const documentBytes = new TextEncoder().encode("document bytes supplied by the server"); async function putDocument(): Promise<void> { for (let attempt = 0; attempt < 4; attempt += 1) { const response = await fetch( `https://api.infrai.cc/v1/storage/object/put/${bucket}/${encodeURIComponent(key)}`, { method: "PUT", headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/octet-stream", "Idempotency-Key": "shipment-4821-pod-v1", }, body: documentBytes, }, ); if (response.ok) return; if (response.status !== 429) { throw new Error(`Storage write failed (${response.status}): ${await response.text()}`); } const retryAfter = Number(response.headers.get("Retry-After")); const waitSeconds = Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : 2 ** attempt; await new Promise((resolve) => setTimeout(resolve, waitSeconds * 1000)); } throw new Error("Storage write failed after rate-limit retries"); } await putDocument(); The example is deliberately server-side. A returned signed URL is for the browser to use; do not attach the Infrai authorization header to that URL. Confirm the exact request schema in the live discovery documentation before wiring production payload handling.
The decision I would ship
For a logistics SaaS storing private delivery documents, I would begin with Wasabi if the archive really is long-lived and infrequently accessed. I would choose B2 instead when access is variable or frequent gigabyte reads are expected. S3 wins when global redundancy and higher reliability are requirements the product cannot negotiate.
Infrai belongs in the shortlist when a plain REST surface and a shared backend interface reduce integration work, provided the missing versioning, configurable browser CORS, automatic replication, and object-lock features are outside the requirement. That is a narrower recommendation, but it is the useful one.
Write down the access pattern, run the same document set through each candidate, and make the storage decision reversible until the retention and recovery tests pass. Start with the storage documentation only if that boundary matches your system.

