Node.js remains a key choice for many teams building Web Applications and SaaS services. When choosing a backend framework for Node.js, developers now have a range of options, each with its unique strengths and ideal use cases.
However, making the right choice can be challenging. So in this article we take a look at the leading frameworks and compare them, including:
Encore is a modern alternative, aimed at teams looking for an integrated and developer-experience focused approach to backend development. Encore is purposefully designed to make it less complex to build event-driven and distributed systems, and solves for both the local dev experience and assists with deployment using robust and scalable services from AWS and GCP.
It works by providing a Backend SDK that lets developers declare infrastructure semantics as part of the application code. Encore then parses the code and creates a fully type-safe model of your application's microservices, APIs, and infrastructure requirements. Encore then automatically runs your local environment, deploys to temporary preview environments for testing, and provisions infrastructure and deploys to your cloud (AWS/GCP).
With Encore you define a service by creating a folder and inside that folder defining an API within a regular TypeScript file. Encore recognizes this as a service, and uses the folder name as the service name. When deploying, Encore will automatically provision the required infrastructure for each service.
On disk it might look like this:
/my-app
├── encore.app // ... and other top-level project files
├── package.json
│
├── hello // hello service (a folder)
│ ├── hello.ts // hello service code
│ └── hello_test.ts // tests for hello service
│
└── world // world service (a folder)
└── world.ts // world service code
This means building a microservices architecture is as simple as creating multiple directories within your application.
Encore lets you easily define type-safe, idiomatic TypeScript API endpoints.
It's simple to accept both the URL path parameters, as well as JSON request body data, HTTP headers, and query strings.
It's done in a way that is fully declarative, enabling Encore to automatically parse and validate the incoming request and ensure it matches the schema, with zero boilerplate.
To define an API, use the api
function from the encore.dev/api
module to wrap a regular TypeScript async function that receives the request data as input and returns response data.
This tells Encore that the function is an API endpoint. Encore will then automatically generate the necessary boilerplate at compile-time.
In the example below, we define the API endpoint ping
which accepts POST
requests and is exposed as hello.ping
(because our service name is hello
).
// inside the hello.ts file
import { api } from "encore.dev/api"
export const ping = api(
{ method: "POST" },
async (p: PingParams): Promise<PingResponse> => {
return { message: `Hello ${p.name}!` };
}
);
Publishers & Subscribers (Pub/Sub) let you build systems that communicate by broadcasting events asynchronously. This is a great way to decouple services for better reliability and responsiveness.
Encore's Backend SDK lets you use Pub/Sub in a cloud-agnostic declarative fashion. At deployment, Encore automatically provisions the required infrastructure.
The core of Pub/Sub is the Topic, a named channel on which you publish events.
Encore makes it very simple to create Topics. For example, here's how you create a topic with events about user signups:
import { Topic } "encore.dev/pubsub"
export interface SignupEvent {
userID: string;
}
export const signups = new Topic<SignupEvent>("signups", {
deliveryGuarantee: "at-least-once",
});
To publish an Event, call publish
on the topic passing in the event object (which is the type specified in the new Topic<Type>
constructor):
const messageID = await signups.publish({userID: id});
// If we get here the event has been successfully published,
// and all registered subscribers will receive the event.
// The messageID variable contains the unique id of the message,
// which is also provided to the subscribers when processing the event.
Express.js, is in essence the most common Node.js web framework. It offers a minimalistic and flexible approach, and has become for its speed and minimal overhead, providing just the core framework features needed to build web applications and APIs.
Nest.js brings a structured, Angular-inspired framework to the backend, embracing TypeScript as a first-class citizen. It offers a modular architecture that organizes code into separate modules, designed to make it easier to maintain and develop larger applications.
Koa.js is created by the team behind Express.js and aims to be a more modern and flexible foundation for web applications and APIs. It uses a middleware stack that executes in a stack-like manner, allowing for more expressive and robust error handling.
Node developers are spoiled with many great frameworks to choose from. However, Encore stands out as the only framework that comes with a solution for automated deployment to production-ready infrastructure on AWS/GCP. This makes it a great choice for startups building with speed and scalability in mind.