Demystifying Serverless

For the past year and a half, the cloud industry has been abuzz with the term “serverless”, which has become both widely popular and (as is usual in technology) widely misunderstood and often misapplied.

And when I mean abuzz, I have the data to show it:

Google Trends for “serverless” (yellow), “serverless architecture” (red) and “azure functions” (blue, of course). Vertical axis is relative popularity over time.

So what is Serverless, anyway?

As everything in technology, you’ll get a different definition depending on whom you ask – vendors will tell you that the best, purest embodiment of the concept is their latest product (cue PowerPoint presentation), architects will tell you it’s a cleaner, more granular approach at building solutions, developers will tell you it’s the coolest thing since sliced bread, and sysadmins will rant on about it being another cloud-centric fad.

If you look at it from a service delivery perspective, the serverless model is the next step forward in terms of abstraction from the PaaS model — it frees you from setting up, provisioning and maintaining your own servers, but the central abstractions are functions (single-purpose services) rather than monolithic applications, and it ties in quite nicely with another industry darling – micro-services, which I wrote about a while ago.

But, from an architectural perspective, it has another nice bonus: Each of your transaction flows can be implemented as an individual function and deployed as a micro-service that can take as input an HTTP request, a custom event, a structured message, etc. It’s every developer’s nirvana — business requirements mapped to pieces of code in a one-to-one basis.

A Journey of a Thousand(less) Servers

From an architecture and development perspective, breaking down an existing application into single-purpose functions, each catering to a particular aspect of your business logic (which, let’s face it, does involve some work) brings a number of advantages:

  • You can independently test, profile and deploy each function
  • You can combine and re-use multiple sets of functions to quickly and easily deliver custom offerings to different sets of customers
  • You can version, phase out and replace individual functions as your business evolves

And doing that on a serverless platform affords you all the benefits of PaaS:

  • Zero maintenance (no fiddling with network, storage or OS patches, with uptime and security managed for you)
  • Faster time to market (developers only need to worry about the application)
  • A literal economy of scale (scalability and performance improvements are managed for you, often at a much larger scale than you could afford)

…but serverless platforms bring a lot more to the table.

For starters, since they have to provide you with fine granularity to run and manage individual functions, they also provide a lot of added value as far as pricing, performance and functionality are concerned.

Yes, an immediately obvious benefit is increased flexibility – functions can scale independently of each other, access different sets of data, and even be written in different programming languages.

But the way I see serverless is as an opportunity to rationalise both your application architecture as well as development processes, and get measurable, actionable metrics to boot.

Tying It All Together

What you need to keep in mind is that serverless does not release you from the responsibility of having a well-rounded development and release cycle, and, more importantly, from delivering services in an integrated and efficient fashion – and make that (and the value that you, as an architect or as a developer bring to the table) more apparent to your business.

And value, these days, is all about focusing on your business, not on running herd on servers, wrestling with fat applications or trying to divine what is going on in their entrails.

So you should look for a platform that can provide you with five key aspects you need to go serverless without hassles and with full awareness of what is going on with your code:

  • Dynamic auto-scaling to cope with sudden increases in demand (and a pricing model that lets you take advantage of quiet periods)
  • Support for a wide variety of development languages and runtimes (preferably with a git-like deployment mechanism you can tie into your CI/CD pipeline)
  • Clear-cut performance metrics that span application and data tiers (with analytical tools that let you easily surface business KPIs as well as tracking down any issues that may arise)
  • Easy integration with multiple data, mobile and real-time messaging services (i.e., SQL and NoSQL databases, but, more importantly, high scalability enablers like message queues and event processing services)
  • Airtight security, from both a development and service delivery standpoint (an often overlooked, but essential piece is a coherent API management solution to unify all your functions and deliver them as a cohesive whole) This is what serverless is really about – fine-grained control of your applications, delivered as a service and freeing you from the weeks (years?) involved in putting that together yourself.

But don’t take my word for it – feel free to investigate more on your own, do a few internet searches, and contribute to the chart I included above. And when you’re ready to try it out for yourself (using nothing but a browser, right now), you can start here – no sign-up required.

(This post originally appeared on LinkedIn)