What is Serverless Computing and How Does It Compare to Traditional Servers?

Developing web applications involves choosing how your code runs. Two popular methods are server-based hosting and serverless computing. This article will show you the differences, using Node.js projects on Heroku (server-based) and Vercel (serverless) as direct examples.

What is Serverless Computing? (A Closer Look)

Serverless computing means you write and deploy code without managing servers. The cloud provider handles all server administration, such as patching, scaling, and ensuring the infrastructure is running. Your code, often called a "function as a service" (FaaS), runs only when triggered, for example, by an HTTP request or a database event. You focus almost entirely on writing your application logic. Because your code runs only when needed, you pay only for the compute time your code is active. This can lead to significant cost savings for applications with variable or infrequent usage.

Benefits of Serverless:

• Automatic Scaling: When demand increases, the platform automatically starts more instances of your function. When demand drops, it reduces the number of instances, sometimes even to zero. This happens without any manual intervention from you.
• Reduced Operational Overhead: You no longer need to worry about server operating systems, runtimes, or other infrastructure maintenance. This frees up developer time to focus on application features.
• Cost Efficiency: The pay-per-execution model means you are billed only for the resources consumed while your code is running. There are no costs for idle servers.
• Built-in Resilience: Serverless platforms typically distribute your functions across multiple data centers, making them highly available and resistant to outages.

Considerations for Serverless:

• Cold Starts: If a function has not been called for a while, it might take a few extra milliseconds for the platform to initialize and execute it for the first time. This is known as a "cold start."
• Platform Specifics: While the idea of serverless is general, each provider has its own ways of configuring and deploying functions. This can make it harder to move your application across different serverless providers.
• Debugging: Debugging issues in a distributed serverless environment can be more complex than on a single server, as functions run in isolated environments and interact through events.

What is Server-Based Hosting (Traditional)? (A Closer Look)

Traditional server-based hosting involves setting up, maintaining, and scaling dedicated servers or virtual machines. You install the operating system, configure the environment, and then deploy your application, which runs continuously on that server. You are responsible for everything from server health and security updates to scaling the server's capacity up or down to handle traffic. This model gives you complete control over the server environment and its resources.

Benefits of Server-Based Hosting:

• Full Control: You have complete control over the server environment, including the operating system, software versions, and custom configurations. This is important for applications with very specific requirements.
• Persistent Connections: For applications that need long-running connections, such as real-time chat applications using WebSockets or streaming services, a persistent server is often a better fit.
• Stateful Applications: It is easier to build applications that keep data or state in memory across requests using a traditional server, though this can make scaling more complex.
• Predictable Performance: With dedicated resources, your application might experience more consistent response times as there are no cold starts or shared resource competition from other users on the platform.

Considerations for Server-Based Hosting:

• Operational Overhead: Managing servers involves tasks like security patching, software updates, backups, and monitoring. This demands significant time and expertise.
• Manual Scaling: You are responsible for scaling your server capacity. This often means manually adding more servers or upgrading existing ones when traffic increases, which can be time-consuming and expensive if not managed well.
• Cost for Idleness: Servers run continuously, consuming resources and incurring costs, even during periods of low traffic or when they are idle.
• Resource Management: You must carefully estimate and manage server resources (CPU, RAM, disk space) to avoid under-provisioning (leading to slow performance) or over-provisioning (leading to wasted costs).

A Simple Way to Think About It: Restaurants vs. Food Delivery

Let's use a very basic analogy to make sense of servers and serverless, even if you are not familiar with computers:

Think of a "Server" like owning and running a restaurant. You rent a building (that's your server). You set up a kitchen, buy all the cooking equipment, hire chefs and waiters, and make sure the lights and heating are always on.

• You control everything: You pick the ovens, decide the layout, and manage all the staff.
• Always on: Your restaurant is open (or ready to open) all day, every day, whether you have customers or not. You still pay rent, electricity, and staff wages.
• Crowds: If many customers arrive, you might need to quickly open up more seating or hire more chefs to keep up. This needs your direct planning.
• Your responsibility: If a pipe bursts or the oven breaks, you are the one who calls for repairs.

Now, think of "Serverless" like using a food delivery app (like ordering pizza). When you want pizza, you just open the app and order. You do not own the pizza oven, the kitchen, or the delivery car. You do not even know where the pizza is made specifically, or who the delivery driver is.

• You focus on the order: You care about getting your pizza, not how the kitchen works.
• Pay per order: You only pay for the pizza when you order it. You do not pay for the oven to be on all day, or for the delivery car to just sit there.
• Crowds: If many people suddenly order pizza, the pizza company handles it. They have many ovens and drivers, and they will simply deliver more pizzas. You do not have to worry about if they can keep up.
• Someone else's problem: If an oven breaks, the pizza company deals with it. You still get your pizza from another one of their locations or ovens.

In short:

• With a server (restaurant), you manage everything yourself and it's always running, costing money even when idle.
• With serverless (food delivery), you just ask for a specific task to be done, someone else handles all the background work, and you only pay when your task runs.

Node.js on Heroku (Server-Based Example)

Heroku is a platform where you deploy your application onto ready-to-use application containers called "dynos." When you deploy a Node.js application, Heroku expects a web server that listens for requests on a specific port. Your application runs continuously as long as its dyno is active. To handle more traffic, you manually increase the number of dynos.

Your Node.js application typically uses a framework like Express to create a web server. The package.json file lists project dependencies, and a Procfile tells Heroku how to start your application.

Code Structure for Heroku:

This is a server.js file for a simple Express application:

JavascriptCopy code

A package.json file would include express as a dependency and a start script:

JsonCopy code

A Procfile specifies the command to execute:

HtmlCopy code

Deployment to Heroku involves pushing your code to a Git repository linked to Heroku, and Heroku builds and runs your application based on these files.

Node.js on Vercel (Serverless Example)

Vercel is a platform known for deploying front-end applications, but it also excels at serverless functions. With Vercel, you write small, independent functions that respond to specific requests. Your code is deployed as a serverless function that activates only when an HTTP request triggers it. Vercel automatically scales your functions up or down to handle any traffic volume, even scaling to zero when not in use.

Vercel detects Node.js serverless functions in an api directory automatically. Each file in this directory represents a separate API endpoint.

Code Structure for Vercel:

This is an index.js file inside an api directory for a simple serverless function:

JavascriptCopy code

This file will be accessible at your project's /api path. Vercel automatically creates an endpoint for it. You don't need to manage a full server or package.json for basic functions, though you can use it for dependencies. Vercel handles dependencies by looking at your package.json if present.

Comparison Table

Which One to Choose?

Your choice depends on your project's specific requirements and constraints.

Look at Heroku or other server-based solutions if your application:

• Needs to be constantly running and available with consistent performance.
• Relies on long-lived connections, such as WebSockets for chat or collaboration tools.
• Requires very specific control over the server environment, including the operating system or system-level dependencies.
• Has predictable and consistently high traffic, making continuous server operation cost-effective.
• Is stateful, meaning it keeps information in memory across multiple requests.

Look at Vercel or other serverless platforms if your application:

• Consists of smaller, independent functions that respond to events (like API requests or webhook calls).
• Has unpredictable or infrequent traffic patterns, where paying only for execution time offers significant cost savings.
• Benefits from automatic scaling up and down to handle variable loads without manual intervention.
• Prioritizes developer focus on application code over infrastructure management.
• Is a static website with dynamic parts (like a blog with a contact form API).

Serverless computing represents a shift in how applications are built and operated, moving the burden of server management to the cloud provider. While server-based solutions like Heroku provide complete control over a persistent server and are well-suited for long-running, stateful applications, serverless platforms like Vercel excel in automatic scaling, a pay-as-you-go cost structure, and reduced operational overhead for event-driven and stateless functions. Both are powerful ways to deploy Node.js applications, but they address different needs and suit different development philosophies. Understanding these differences helps you pick the best fit for your next application.