How object storage could save your mobile application

By Danny Bradbury

So, you’ve developed a mobile application. It’s a photo-sharing app that lets you record voice messages about your photos, and it is designed to be used by hundreds of thousands of people. Your application needs to store images and sound recordings, in addition to information about them — known as metadata — such as where and when they were taken. Traditional storage may not be appropriate for this. Instead, you may need object storage. Here’s why.

Next-gen apps need next-gen storage

Traditionally, computers used two types of file storage: block and file. Block storage is the lowest level of storage, attaching directly to an operating system (OS) to let it control individual “blocks” on the hard drive. Your application can tell your operating system to store files using block storage.

Sign up for our newsletter
Stay on top of the latest mobile news and insights.

File-based storage involves a file system that translates between the OS and the hard drive, enabling different operating systems to use the same storage device. It organizes data into files and stores them in hierarchical, folder-based structures. It keeps track of these files by storing metadata alongside them, containing descriptions of the file’s attributes.

Block and file scale well, up to a point. File-based structures need to manage lots of data about those files (metadata). In the days before vast mobile applications that store lots of unstructured data such as images and sound recordings, traditional file-based storage was OK because applications needed relatively few files. That’s all changed now. We need a different kind of storage that manages the files — and the data about them — more effectively.

Object storage brings several benefits, all of which are useful for mobile applications manipulating lots of data.

Accessibility advantages

Object storage talks directly to applications rather than the OS, and it provides high-level access to storage using application APIs. Whereas an OS may need a series of complex commands to access block storage, an application developer can send a single command to manipulate an object.

This makes it easier for analytics applications to ask the storage system questions — such as how many pictures were taken in New York yesterday, or how many users have recorded messages more than a minute long — so that you can begin offering them a premium version of the service. Analytics apps may also ask how many pictures were taken with Android devices rather than iOS so that you can plan development priorities for your mobile app.

Scalable storage structure

Object storage is far more scalable than traditional file-based storage because instead of storing files in a hierarchical structure, this approach stores them in a flat structure. This means the system doesn’t need to store data about where those files are and how they relate to each other.

Any metadata about an object is also stored directly as part of that object, rather than in a separate file. That makes object storage far more efficient at handling very large numbers of records. As mobile applications scale out to large numbers of users, that becomes more important.

Reliability through replication

Because objects are self-contained and don’t rely on complicated folder structures or separately stored metadata, it is easier to replicate them. You can create multiple replicas of objects on different physical nodes, meaning that if one node fails, the application can still retrieve objects from the others.

That’s more difficult to do on file or block storage because you need to tell the OS what you’re doing, and replicate the complex metadata structures along with the files themselves.

Cost concerns assuaged

Object storage is designed to run on commodity hardware and doesn’t need proprietary block and file storage architectures running on expensive, vendor-specific hardware to run. This is important when you’re dealing with large volumes of data replicated between different physical storage devices, which is precisely what you’d be doing when scaling a mobile app.

It’s also a cloud-native concept, often available as a service. It’s accessible from mobile applications using simple APIs that operate over HTTPS. It means that startups with a great idea for a mobile app can get it up and running easily without burning cash on costly vendor-specific equipment; they need only pay for the capacity they want and can scale it up as necessary, all without installing anything locally.

If you haven’t considered this innovative type of storage for your mobile application, it’s worth a serious look. It could save you significant resources early on in your development, while easing the growing pains once your app is a success.