The backbone of any application is the infrastructure that it is built around. There is immense effort and pain that goes into creating the infrastructure that is necessary to give you the desired end result, which is an application that delivers seamlessly. For developers, this is a chore that they would love to do without. And in the modern day this is becoming a reality, all thanks to server less computing which helps to relieve them of this burden. Because server less computing is all about handing over this responsibility of infrastructure to the cloud provider who will dynamically manage the allocation of machine resources.

In saying that you have to understand that the term ‘’server less’’ is actually a misnomer. It doesn’t imply that the system is not backed up by a server, it just means that the developer does not have to worry about the infrastructure requirements at all. All of this will be handled completely by the cloud provider, who will deliver the exact amount of storage and memory as well as compute. The developer does not have to code for it or even think about it. Another added advantage of such a server less system is, that you only have to pay for the resources that are used up while the application is up and running, and you don’t end up paying for pre purchased capacity. The allocation of server resources to a particular application by the cloud provider is also based on the workload requirements of the particular application and is never predetermined. The biggest question that is to be answered now is that if this server less, next generation software architectures are gaining popularity where does that leave the traditional, relational database? Because even though we don’t realise it, they still do play a very crucial role as a component of most applications used till date.

Because in the past we have always had well proven and robust database models when it comes to deploying applications from monoliths to micro services and to platform as a service (PaaS) solutions. Monoliths are a single large server which will power dozens of applications and microservices are a collection of small independent modular services, each of which is capable of running a unique process designed for a specific business goal. Whatever the model might be they all rely on the provision of database servers whether it be on the premises, in the cloud or using platform as a service (PaaS) solutions. And even though this database system does provide you with the ability to scale down, scale up or scale out your database dynamically in response to the workload this is not meant to be done all that frequently. It can only be done periodically in response to major changes that are coming the way of your business. Therefore if you have a relatively constant and predictable workload then you are better off having a dedicated database server because they usually adhere to a predictable pattern. If you are not expecting dynamic changes throughout the day but just a couple of changes within a year then a database server is the way to go.

But with changing times and next generation challenges what you need is the next generation application. Because in the modern day, the workload for an application is highly unpredictable, sporadic and intermittent. For example you might have volumes of data, queries and transactions which might occur within a couple of seconds or minutes each day and not being repeated in the same manner for the next couple of hours. This kind of challenge occurs very frequently in workloads with regard to stock trading, online gaming and sometimes even analytics. Therefore you need an application that can match up to these sporadic changes and work accordingly.

What does it mean to be a server less database?

Being a server less database means decoupling your storage and your computer. But in order to be completely server less, what should actually happen is that your compute should not be having an existence during those times when it does not process any data. Essentially this means that your database layer will have to automatically start up, automatically shut down and also automatically scale up and scale down based on the workload of the application. Your job will only be to define an end point to the database and connecting your applications. Once this is done the underlying technology will do the needful and scale the compute and storage resources depending on the needs of the application. This in turn provides these applications with greater flexibility and performance driven goals. But most of all what it provides you with is, high levels of cost effectiveness because, you end up paying for the database capacity that you will be using only when your database is active instead of choosing the amount of resources you are going to be using up upfront.

What this means for the future?

With the incredible changes that we see in the technology of the modern day it has become inherent that we make constant changes in the development and deployment patterns of applications. Dynamic scaling is becoming a critical component for next generation data architecture and therefore server less databases are becoming inherently important. And although it certainly does simplify operations on one level, it also brings about a whole new set of requirements.

And that is the reason we are still not there just yet. If we really want server less data bases to take hold there is still a lot of progress and work that needs to be done. But, if done correctly it has enormous potential in the coming years and that is a reason that it has got the attention of many people as being the next big thing in the world of application development. Because when done correctly it will be more than just another method of coding. It will end up changing the way the world thinks about programming and its relation to the underlying infrastructure of an application all together.

But whether, in reality a server less database is going to be much more efficient than relational database, we will have to wait and see. Because as we all know old habits die hard and it just might be a tough job convincing people to shift from a reliable relational database to the unpredictability of a server less database.