Explore serverless computing. Eliminate infrastructure management, focus on code, and embrace auto-scaling and pay-per-use models for modern applications.
Christina Harker, PhD
Serverless computing, also known as Function as a Service (FaaS), is a cloud computing model where developers can build and run applications without the need to manage underlying server infrastructure. This can be a major benefit in many different kinds of businesses. In a serverless architecture, the cloud provider will dynamically manage the allocation and provisioning of resources based on the application's demand.
With serverless, developers don’t need to provision or manage servers, VMs, or containers. The cloud provider handles all the infrastructure management tasks. This includes things like capacity planning, scaling, and maintenance.
Serverless applications are triggered by events. What kind of events trigger serverless apps? HTTP requests, database updates, file uploads, or scheduled tasks, for example. And when an event occurs, the associated code (known as a function) is executed and the necessary resources are allocated on-demand. This all means that the application remains dormant when not processing events and that results in cost savings.
Serverless platforms automatically scale the resources allocated to a function based on the incoming workload. The provider will make sure there are enough resources available to handle the demand, and this eliminates the need for manual scaling.
Serverless computing follows a pay-as-you-go pricing model. Users are billed based on the actual usage of computing resources. In turn, that means that costs are only incurred when functions are executed, and users aren’t charged for idle time.
Serverless abstracts away infrastructure management. That abstraction allows developers to focus on writing code rather than dealing with server provisioning, scaling, and maintenance tasks.
Serverless platforms automatically scale resources in response to workload changes. Applications can handle sudden spikes in traffic without manual intervention. This advantage means it’s easier to ensure optimal performance and responsiveness.
Pay-per-use pricing in serverless computing eliminates the need for overprovisioning or paying for idle resources. Users only pay for the actual execution time and resources used by their functions, potentially resulting in cost savings.
Serverless architectures can also help by promoting faster development cycles. They allow devs to focus on building core application logic, instead of having to spend time on managing infrastructure. Because it frees up time, serverless also enables rapid prototyping, deployment, and iterative development.
Serverless computing workers well for event-driven and highly scalable applications. This includes things like microservices, real-time data processing, chatbots, IoT backends, and web APIs. But serverless may not be right for applications with long-running or continuously active workloads. That’s because serverless functions have certain execution time and resource limitations that are imposed by cloud providers.
Popular serverless platforms include AWS Lambda, Azure Functions, Google Cloud Functions, and IBM Cloud Functions. These platforms all support different programming languages. And they provide integration with other cloud services and event sources.
While serverless computing offers numerous advantages, there are also some potential disadvantages you will need to consider.
When a serverless function is triggered after a period of inactivity or if it's the first invocation, there will likely be a noticeable delay. This is due to a cold start. Cold starts happen because the cloud provider needs to allocate and initialize the necessary resources to execute the function. So while that is happening, you have a delay. This latency usually impacts applications that require near-instantaneous response times the worst.
Serverless functions have execution time limits imposed by cloud providers. Functions exceeding these limits will probably be terminated abruptly. That can of course be problematic for tasks that require longer processing times. Some providers also enforce limitations on the amount of memory or CPU resources a function can use.
Serverless platforms often have proprietary programming models and specific integration points with other cloud services. Unfortunately, this can lead to vendor lock-in. It becomes hard to migrate applications to alternative platforms and it’s difficult to run them in a hybrid or multi-cloud environment.
Serverless abstracts away infrastructure management. While this does provide a lot of convenience, the tradeoff is that you have limited control. Developers end up with less control over the underlying servers, networking configurations, or low-level system operations. If you have an application with specific infrastructure requirements or complex networking setups, this can definitely turn into a disadvantage.
Testing and debugging serverless applications can be worse and more complicated compared to traditional architectures. You have to take into account the distributed nature of serverless systems. On top of that, you’re dealing with event-driven workflows and need to set up appropriate logging and monitoring mechanisms so that you can diagnose and troubleshoot issues effectively.
While serverless architectures can be cost-effective for low or sporadic workloads, that is not true for apps with continuous or high-frequency execution patterns. For those kinds of apps, serverless can quickly become very expensive. Essentially, the pay-per-use pricing model can lead you into unexpected costs if the application experiences frequent spikes in traffic or high compute demand. Which is what you want, if you’re growing.
Serverless functions are typically stateless, meaning they don’t retain any in-memory state between invocations. If an application requires maintaining session data or shared state, additional mechanisms like external databases or cache systems have to be used. And that only adds complexity to the architecture.
It's important to evaluate these disadvantages against the specific requirements and characteristics of your app or apps. Some limitations can be handled through careful architecture design, leveraging additional services, or combining serverless components with other deployment models. But that doesn’t mean that Serverless is automatically the right choice for you or your application/s. If you’re trying to figure it out and could use some free cloud advice, reach out to Divio to discuss your needs. Even if you don’t end up using the Divio PaaS, we are happy to share our expertise and knowledge with you and help you make a choice that you’ll feel confident about.