Serverless in the real world

This is an article by Kumar Harsh—the special mention winner of Blogathon contest.

Serverless architecture is one of the hottest entrants to the technology industry. It helps developers to ship independent functions of code instead of full-fledged applications, eliminating the need for extensive hosting management. In this article, we will look at some of the reasons why serverless is the next big thing, and explore some excellent use cases.

What is serverless?

Serverless is an approach to building apps that does not rely on traditional servers. Instead of servers, you can host and remotely invoke individual functions of code, just like any other function in your local programs/apps. The flexibility serverless apps provide opens up a whole new world of possibilities.

Serverless: Weighing the pros and cons

Like everything else, serverless has its pros and cons. Let’s use them to determine when it's best to use serverless.

Benefits

Major benefits of serverless architecture include:

Cost optimization:

One of the most significant benefits of switching to serverless architecture is that you only pay for the time your functions are running. This reduces the cost you'd otherwise incur running and hosting your servers 24/7.

Reduced time to market:

With serverless, you only need to worry about developing and maintaining functions. You eliminate tasks related to app maintenance, server management, complex DevOps pipelines, and more. This reduces the overall time to market for your apps.

Enhanced scalability:

With serverless, you can configure your setup to scale for any number of incoming requests. You do not have to provision a fixed number of servers; your functions scale automatically with incoming traffic.

Microservices compatibility:

Serverless makes it very easy to develop microservices-based apps, since you can break your microservices down into organized functions. 

Challenges

Here are a few challenges of using serverless architecture:

Vendor lock-in:

Migrating your serverless app between FaaS providers can  be challenging. If your provider makes changes to their pricing plan, you might not be able to shop around for a better deal.

Cold starts:

Cold start refers to when your app takes longer than usual to start, because it hasn't been invoked for a long time. Cold starts can add unnecessary latency to your serverless apps.

How does serverless fit in the real world?

Here are some ways serverless architecture can be utilized in the real world:

Scheduled tasks

Scheduled jobs are set to run at specific points in time. They could be set to repeat every hour, day, week, month, or even year. These jobs may be triggered without the involvement of a live server application that runs 24/7.

You can set up independent serverless functions as a CRON job, or any other recurring service, to invoke them at their specified time. Using CRON and serverless can be a much cheaper, and equally effective, alternative to a full-fledged web server.

Asynchronous jobs

Asynchronous jobs are not required to run in any particular order or fashion. They can be run parallel, and still produce the same result. Famous examples of asynchronous jobs include file type conversion and media processing. In most cases, you do not require your app to do jobs, like transcoding a video, instantly; your app can do them in the background while the user proceeds with other tasks in the app.

Serverless architecture can isolate features from your app’s main logic. You can invoke a function to process user-generated content or run background tasks whenever needed. 

Pay-per-use

The pay-per-use pricing model is common in the serverless realm. One of the main reasons for this is that it provides customers the freedom to pay only for what they use—not for the overall time they have been subscribed to a service. 

The serverless model sets cost based on your number of function invocations and the running duration of these functions. This makes it a cost-effective way to build web apps based on this model and charge the users based on the number of times they do a particular task in the app, such as running an operation or initiating a monetary transaction.

Message-based Tasks

Message-based tasks are triggered by sending a message event with required input data. These overlap with asynchronous tasks but differ in an important way— message-based tasks are mostly run in the background, while async tasks incorporate real-time parallel execution tasks.

Tasks, such as sending a welcome email to your new user, or running a database clean-up routine once a certain threshold of stale records is reached, fall under message-based tasks. Most popular serverless platforms, such as Catalyst by Zoho,  can easily handle these tasks.

DevOps

DevOps is another hot market for serverless technology. DevOps pipelines require a series of steps to be performed when triggered to build and deploy an application. This is usually handled by a DevOps server such as Jenkins or CircleCI.
    
However, you can leverage serverless programming to write functions that can replace each step in your CI/CD pipelines and host your own serverless DevOps setup! Consider isolating some of the steps in your CI/CD pipelines, such as creating a build or running a suite of tests, using serverless computing.

Final Thoughts

All in all, serverless architecture is promising for the cloud-native industry. Even complex systems, such as app backend servers and payment gateways, can be made simple using serverless technology. With features like pay-per-use and automatic scaling, serverless has the potential to replace some of the traditional approaches to building web apps.