The Dawn of Serverless Computing

Wait, what?  How can you have computing with no servers?  Truth is you can't but let me explain the concept.  

While a bit of a misnomer, serverless computing is quickly growing from a theoretical architecture to a real honest to goodness cloud based architecture. Note an important caveat is that this is an option only if your application is architected for the cloud (i.e. stateless microservices).  If you can't claim victory there, then serverless computing isn't an option for you, yet.  You will have to refactor first.

With that, the premise behind "serverless" computing isn't that there are no servers in your stack -- that awesome code you wrote has to run somewhere after all.  The model in a serverless world is that some other provider handles the servers and distribution of work on those servers leaving developers to focus on code that differentiates your product from competitors.

A very good example of this concept is AWS' Lambda compute infrastructure. With Lambda, developers write their function, provide some specs about the function and upload it to Lambda.  The code then executes in response to an event such as a notification via SNS, a DynamoDB table update or some other event you want to stimulate your function.  There are no dedicated virtual servers running that may or may not be sitting idle for long periods of time -- in other words there is no wasted compute capacity essentially waiting to be busy.

So why is this model interesting and why should you be paying attention to it?

There are a few primary reasons to consider a serverless architecture, mostly related to cost.  The price point for serverless compute infrastructure is ridiculously cheap compared to renting virtual servers and there is no cost/burden on your operations teams to monitor, maintain and patch your servers -- that task gets offloaded to the provider.  Despite all of our advances in the cloud over the last decade, we are still saddled with huge amounts of waste and unused compute capacity.  Things like raw compute such as Lambda or the spot market are nothing more than ways to package up and sell that unused capacity.  And if your application can run in those environments, you're leaving a LOT of money on the table if you don't take advantage of that.

The other interesting side effect of a serverless architecture is from the security perspective ... the topology of your application becomes an ephemeral one that is constantly shifting in response to events which are firing.  There are no more long running processes on dedicated servers.  This makes for a more challenging attack surface for someone to hack.  It should be noted that this also makes your application more difficult to debug so you need to make sure you have a rich/robust monitoring and logging strategy in place.

So this all sounds interesting and hopefully it makes more sense now, but what is driving a serverless architecture?  The cost and security aspects are certainly key drivers but another more important driver is ultimately the main benefactor here.  Innovation.  Innovation is the lifeblood of any company and this is especially true in the software industry.  The pace of innovation has accelerated and is showing no signs of slowing down so when you think of the time and energy that goes into maintaining your own compute resources that is time and energy that could be spent elsewhere to help your company out innovate your competitors.  And that is ultimately what it's all about.