Serverless APIs and Microservices Ecosystem Exploration

Serverless technologies have been around for the last couple of years and today are trending on blogs, news and obviously Twitter. If we need to be honest though, most of the technologies that we know as leaders of the serverless generation of applications nowadays are around the corner for a little bit longer, even a decade ( e.g. DynamoDB ). As a Cloud and APIs / Microservices enthusiast myself, I couldn’t be more happy with how the evolution of engineering has grown in a way that we could not easily predict. Maybe Werner Vogels or Kin Lane could, but I definitely wasn’t in a position back in the day to see the future of those tropical at the day newborn technologies.
In this article, I am aiming at discussing the amazing article by Jignesh Solanki which explores the vast ecosystem of serverless architectures.  According to wikipedia:
Serverless computing is a cloud-computing execution model in which the cloud provider dynamically manages the allocation of machine resources. Pricing is based on the actual amount of resources consumed by an application, rather than on pre-purchased units of capacity. It is a form of utility computing.
Serverless computing still requires servers, hence it’s a misnomer. The name “serverless computing” is used because the server management and capacity planning decisions are completely hidden from the developer or operator. Serverless code can be used in conjunction with code deployed in traditional styles, such as microservices. Alternatively, applications can be written to be purely serverless and use no provisioned servers at all.

 A Serverless Ecosystem

The article of  Jignesh shares amazing info on how the ecosystem has been played out and also has created some amazing visualizations.

Below I tried to annotate it a bit and I have to admit. The aesthetics of what I create is definitely not great, but I think it works.

Serverless Ecosystem Annotated
Serverless Ecosystem Annotated according to Michael’s feelings


Monitoring your serverless is core in any application. The first days of the serverless world monitoring were not always there but thank god the industry quickly caught up to speed. Personally, I am a huge fan of such solutions and most of this comes from all the times I was overconfident about one of my deployments that finally crashed when I was sleeping.

The many solutions listed are just a small subject of the bigger picture available out there.

Backend as a Service – BaaS

Backend as a service may be a bit of overreaction to what’s really happening out there in terms of APIs and Microservices design when it comes to serverless but it’s okay. A new buzzword. We all love buzzwords!!

Functions as a Service – FaaS

This makes a bit more sense and simplifies the whole process of developing solutions that are not vendor locked. In this category, you have docker as the ultimate winner. Even though there are other solutions like dokku, no-one can compete with the docker ecosystem mainly because of the vast open source community around it.

Serverless Databases

This is not something new. It is as old as the first cloud database offering was available. We can definitely see better offerings like DynamoDB or Firebase, but still. They are the same old NoSQL databases that we already know and love, just with better support.

Personal opinion bomb: Definitely try the serverless databases! It will save you tones of time and they are awesome!

Serverless/APIs Authentication & Authorization

Again you will see many options there. Personally, this is something that has to do with the business model in my understanding. If you plan to create the next Facebook, go with your own auth system. Otherwise, outsource it!

Serverless Monitoring Platform

If you don’t want to set up your own ELK stack then there are many offerings out there! You can even hack your way around CloudWatch, NewRelic or other solutions.

No matter what you finally choose, you should never ignore monitoring!

Serverless Tools/Platforms

The offerings for platforms out there are soooo many. Last week I visited and IBM, Amazon, Azure they were all pitching their serverless offerings.

Serverless Frameworks & Libraries

This is my favorite part!

Personally, I have been using and chalice but after reviewing this awesome book, I feel confident with claudia as well.

Those frameworks they actually do exist to make our life much much easier and you should trust them in my opinion. Especially for small-scale apps.

Serverless APIs: Example in Chalice

$ pip install chalice
$ chalice new-project helloworld && cd helloworld
$ cat

from chalice import Chalice

app = Chalice(app_name="helloworld")

def index():
    return {"hello": "world"}

$ chalice deploy

$ curl https://endpoint/api
{"hello": "world"}

Conclusion: It is safe to try Serverless in your Microservices at Home

You can understand the hype of serverless just by going in Amazon search and search for books with the keyword ”serverless”. Repeat this in six months and then again in a year. I have been monitoring the space for the last couple of years and have read every possible book in the space. You will notice as I did as well, that the number of books grows by the day.
Server-less is more