Infrastructure & Reliability
Object Storage Is Not a Backup Strategy by Itself
Object storage is useful for durable, addressable files—but a bucket alone does not give you a recoverable system. The real design includes versioning, retention, integrity checks and tested restores.
Object storage is easy to misunderstand because its interface looks familiar. You create a bucket, upload a file, and retrieve it later using a key. That can feel like putting files on another disk. But object storage is a different model: an object is addressed by a key inside a bucket, and the service manages how that object is stored and made available. The abstraction is valuable precisely because the application does not need to manage a filesystem or a block device for every file.
Objects, buckets and keys
A bucket is a namespace and policy boundary. A key identifies an object within it, such as backups/hserver/2026-10-26/database.dump.zst. The object can include data and metadata, while the storage service handles the underlying placement and replication according to its own implementation and configuration.
S3 is an API and ecosystem, not a synonym for one specific provider. Many services offer S3-compatible interfaces, including cloud object stores and self-hosted systems. Compatibility is useful, but it should not be mistaken for identical behavior: lifecycle rules, versioning, consistency guarantees, retention controls, request limits and pricing can differ. Test the operations your application actually depends on rather than assuming that every implementation behaves exactly like Amazon S3.
Why not use a normal disk?
Block storage presents addressable blocks to a machine, which can create a filesystem or host a database. A filesystem organizes files and directories for workloads that need operations such as opening files, changing parts of them and coordinating concurrent access. Object storage instead works well for complete objects accessed through an API: backup archives, images, documents, logs, recordings, static assets and software artifacts.
This makes object storage a strong fit for large collections of files that should be accessed independently of one particular server. It is usually not a drop-in replacement for a database disk or a filesystem that expects low-latency random writes. Applications should be designed around object operations, including upload, download, listing, metadata and deletion.
Durability is not the same as recoverability
The most important distinction appears during an incident. A provider may keep stored objects highly durable, but durability cannot protect you from every operational mistake. A process can upload a corrupted archive successfully. A credential with excessive permissions can delete good data. A lifecycle rule can expire the very objects you needed. A backup job can report success even though the database dump is incomplete or the restore procedure no longer works.
A useful backup design therefore treats object storage as one component of a recovery system. The workflow should produce a consistent backup, encrypt it where appropriate, upload it, verify its integrity, retain it according to policy and periodically restore it into a separate environment. Checksums help establish that the bytes you retrieve match the bytes you intended to store. A restore test establishes something stronger: that the data can actually be used.
The controls that matter
- Separate credentials and permissions. The backup writer should not automatically have permission to erase every retained backup. Use the narrowest practical permissions and keep administrative credentials away from routine jobs.
- Define retention deliberately. Versioning can help recover from accidental overwrites or deletions, but old versions still need a lifecycle and cost policy. Where supported and appropriate, immutable retention or object lock can add protection against destructive changes.
- Verify the content. Record checksums and backup metadata, and validate the archive or database dump before considering a backup complete.
- Keep failure domains separate. A second copy on the same host is not an off-site backup. Consider independent credentials, accounts or providers according to the threat model and recovery requirements.
- Measure recovery, not just upload success. Track the age of the latest verified backup, restore-test results, expected recovery time and the amount of data that could be lost since the last usable recovery point.
- Understand the bill. Capacity is only one cost. Requests, retrieval, egress, minimum storage duration and retained versions can all affect the total.
A practical pattern for a Linux server
For a small Linux environment, a reasonable starting point is to create application-consistent backup files locally, encrypt sensitive archives, calculate checksums, and upload them to a private bucket using a dedicated service credential. Keep a manifest containing the backup timestamp, source, size, checksum and format. Alert when a backup is missing or fails verification, and run a scheduled restore test into a disposable directory or isolated machine.
Do not delete the local recovery copy merely because the upload command returned success. First verify the remote object and make sure the retention policy leaves enough independent recovery points. Local disk pressure is real, but removing the only known-good copy before validating the remote one turns a storage optimization into a recovery risk.
The exact tools are secondary. The same principles apply whether the destination is a managed S3-compatible service, Backblaze B2, another cloud object store or a self-hosted object-storage cluster. The critical properties are independent failure domains, controlled access, verifiable data and a restore process that has been exercised.
The useful question
The question is not simply, “Did the file reach object storage?” It is, “Can I recover the service from the data I have retained, even if the original server is gone and the routine backup process has failed in a way I did not notice?”
Object storage provides a flexible place to keep objects. A recovery strategy adds the policies, checks and tested procedures that make those objects useful when something breaks.