Short answer: the cheapest private object storage for app backups is the option that meets your measured restore deadline after transfer, request, and operational costs are included; for large gaming reports, run the same authenticated Range-download drill in the EU and US before choosing.

Pick this operating profile when... Prove it with... Reject it when...
Restore throughput comes first sustained bytes per second at the customer edge the slowest valid run misses the recovery deadline
Predictable restore spend comes first an itemized bill for one representative drill request or transfer dimensions cannot be reconciled
Low operational load comes first deployment time, alert count, and drill failures the team must maintain a special download path
Residency comes first a region-by-region data-flow review replicas or logs cross an approved boundary

This is a field guide for a concrete job: serving generated match and economy reports to authenticated customers after an app-data restore. Those reports are large enough that a provider's headline storage rate doesn't settle the decision. The download path, concurrency, geography, cache behavior, and recovery deadline do.

How should app backup restore costs shape EU/US private object storage?

Start with the restore, not the upload. A backup that is cheap to retain but cannot deliver a customer's report inside the recovery objective is the wrong backup. For this workload, “restore” means more than copying an object into a production bucket. It means an authenticated user can begin and complete a download, partial requests work, authorization remains enforced, and operators can explain the result from logs and metrics.

Backblaze B2, Cloudflare R2, AWS S3, and Wasabi can all enter the candidate list named in this comparison. The supplied evidence does not establish current, directly comparable EU/US prices for them, so a universal cheapest-provider ranking would be made up. I'm not sure which one will produce the lowest restore bill for your request distribution. Nobody can know from stored bytes alone. Current provider quotes plus a representative bill would resolve that uncertainty.

Model the bill as dimensions rather than one attractive number:

total = retained data + write operations + read operations + transferred data + required platform work

The last term is deliberately broad. It includes the application capacity used to authorize and proxy downloads, the telemetry retained for audit and debugging, and the engineering work required to keep recovery drills routine. Don't convert it into a fake dollar estimate. Record it beside the provider invoice so a low transfer line does not hide a high operating burden.

The same rule applies to regions. “EU” and “US” are test locations, not performance guarantees. Execute the identical object set, concurrency schedule, and authentication flow from both customer regions. Then compare like with like.

Pick by the shape of the recovery

Pick the throughput-first profile when several customers may retrieve multi-gigabyte generated reports at once. Measure time to first byte and sustained throughput separately. A fast first byte followed by a slow stream feels responsive in a dashboard but still loses the recovery race. Track both.

Pick the spend-first profile when restores are rare, planned, and allowed to take longer. The catch is that a single tiny drill won't expose the request and transfer shape of a real event. Use a manifest that represents the mix: a few large report bundles, many small metadata objects, and retries. Keep the manifest stable across candidates.

Pick the operations-first profile when the on-call team is small. A design with fewer moving pieces can be preferable even if one invoice dimension is higher, because authentication, retry behavior, and audit evidence still have to work at 03:00. This isn't a slogan. Count deployment steps, pages, and manual actions during the drill.

Pick the residency-first profile when customer contracts define where report data may live or travel. Map four arrows in plain words: backup writer to object store; object store to restore worker; restore worker to download service; download service to customer. Attach region and identity boundaries to every arrow. Any unknown arrow is a failed review, not a footnote.

Short version: storage selection is workload selection.

Instrument one authenticated restore path deeply

The cleanest comparison keeps the application boundary constant. The customer asks the Node.js service for a report. The service authenticates the request, resolves an opaque object URL through its own trusted metadata, forwards the optional Range header, and streams the response. The object stays private; the app owns authorization.

Here is the diagram in words: browser -> identity check -> report lookup -> private object fetch -> streamed response. Metrics sit around the final two arrows. Logs join the request ID, report ID, region, upstream status, byte range, and duration. No credential reaches the browser.

The following TypeScript is intentionally a narrow adapter. authorize and resolvePrivateObject are application interfaces, so the storage candidate can change without rewriting the HTTP handler.

import { createServer, type IncomingMessage, type ServerResponse } from "node:http"; import { Readable } from "node:stream"; import { performance } from "node:perf_hooks"; type ObjectTarget = { url: URL; headers: Record<string, string>; fileName: string; }; declare function authorize(req: IncomingMessage): Promise<boolean>; declare function resolvePrivateObject(reportId: string): Promise<ObjectTarget | null>; declare function observeRestore(sample: { reportId: string; status: number; durationMs: number; contentLength: number | null; partial: boolean; }): void; createServer(async (req: IncomingMessage, res: ServerResponse) => { const startedAt = performance.now(); const url = new URL(req.url ?? "/", "https://reports.example"); const match = url.pathname.match(/^\/reports\/([a-zA-Z0-9_-]+)\/download$/); if (req.method !== "GET" || !match) { res.writeHead(404).end(); return; } if (!(await authorize(req))) { res.writeHead(401, { "Cache-Control": "no-store" }).end(); return; } const reportId = match[1]; const target = await resolvePrivateObject(reportId); if (!target) { res.writeHead(404, { "Cache-Control": "no-store" }).end(); return; } const upstreamHeaders = new Headers(target.headers); if (req.headers.range) upstreamHeaders.set("Range", req.headers.range); const upstream = await fetch(target.url, { headers: upstreamHeaders }); const responseHeaders: Record<string, string> = { "Cache-Control": "private, no-store", "Content-Disposition": `attachment; filename="${target.fileName.replaceAll('"', "")}"`, "Content-Type": upstream.headers.get("content-type") ?? "application/octet-stream", }; for (const name of ["accept-ranges", "content-length", "content-range"]) { const value = upstream.headers.get(name); if (value) responseHeaders[name] = value; } res.writeHead(upstream.status, responseHeaders); if (upstream.body) Readable.fromWeb(upstream.body).pipe(res); else res.end(); res.once("finish", () => { observeRestore({ reportId, status: upstream.status, durationMs: performance.now() - startedAt, contentLength: Number(upstream.headers.get("content-length")) || null, partial: upstream.status === 206, }); }); }).listen(8080); 

Content-Disposition: attachment tells the browser that the response should be downloaded, and its filename parameter supplies a suggested name. The header needs careful quoting and sanitization; the MDN reference documents its syntax. Range behavior deserves its own test because interrupted large-file downloads should not silently restart from byte zero.

One sharp edge remains: a completed HTTP response is not proof that the customer received a valid report. Put a checksum and expected size in the backup manifest, verify them after a drill, and record pass or fail separately from transport status. Green transport metrics with a bad artifact are worse than a loud failure because they create false confidence.

Turn the drill into evidence

Measure the whole path.

Run a cold and warm sequence for each region, but label them rather than averaging them together. Use the same report manifest and concurrency. Capture p50 and p95 time to first byte, p50 and p95 completion time, delivered bytes, partial-response count, retry count, and application CPU time. For the bill, preserve the provider's original line items and the exact drill window. Make one dashboard panel answer one question: can customers retrieve reports before the recovery deadline? Put the deadline beside the completion-time distribution. A second panel explains why: throughput, upstream latency, active streams, and retry rate. An alert should fire on a missed service objective or a sustained throughput collapse, not on every isolated slow object. Use a unique drill ID everywhere — request logs, metrics labels with controlled cardinality, the manifest, and the billing worksheet. This makes the before/after crisp. Before a storage change, run the fixed manifest. After the change, run it again from the same regions and compare distributions plus bill dimensions. Keep raw samples; an average can hide one region's long tail.

Lifecycle policy belongs in the review too. AWS documents lifecycle rules as a way to manage objects through transitions and expiration. Treat that as an example of the policy category, not evidence that every candidate uses identical semantics. Verify the configured retention and deletion behavior for each candidate using its current primary documentation, then test the policy on disposable objects before production rollout.

Know when this field guide is not suitable

This approach is not suitable when customers download directly from public objects, because the authentication boundary and proxy measurements describe a different architecture. It is also a poor fit for tiny configuration backups where integrity and recovery-point objectives dominate and large-file throughput barely matters. Use a simpler encrypted backup-and-restore drill there.

Stick with an existing storage arrangement when it already passes regional recovery drills, its bills reconcile, and migration risk exceeds the measured gain. Switch only when the evidence shows a meaningful miss: deadline, residency, integrity, or operating load. Price can break a tie, but a price page by itself cannot certify a recovery path.

The limits are clear. This method does not name a permanent cheapest vendor, predict an untested region, or turn one clean run into a guarantee. It produces something more useful: comparable evidence for the app, objects, customers, and recovery deadline that actually exist.

References