Fastify Framework. Benchmark in comparison with Express

In the evolving landscape of web development, choosing the right framework can significantly influence the performance, efficiency, and scalability of your applications. Among the plethora of options, Fastify has emerged as a noteworthy contender, especially when compared to the venerable Express framework. This post delves into the Fastify framework, exploring its advantages, optimal use cases, and how it stacks up against Express.

Fastify Framework Overview

Fastify is a high-performance web framework for Node.js, designed with speed and efficiency in mind. It aims to be both a lightweight solution for building highly scalable server-side applications and an extensible platform through a rich ecosystem of plugins. Its development is driven by the need for a fast and low-overhead framework that doesn’t sacrifice on features or flexibility.

Programming Tasks Fastify Excels At

Fastify shines in scenarios where performance and speed are critical without compromising on the developer experience. It's particularly adept at handling:

• High-Throughput Applications: Fastify's efficient request handling mechanism makes it ideal for applications that require handling thousands of requests per second.
• Microservices: With its low overhead, Fastify is a perfect fit for microservices architectures, allowing services to communicate efficiently and swiftly.
• API Development: Fastify's built-in schema-based validation and serialization offer a robust solution for developing secure and well-documented APIs.

Core Features and Their Mechanics

• Middleware and hooks support. Fastify hooks and middleware are mechanisms provided by the Fastify framework that allow you to intercept and modify the request/response lifecycle. They provide a way to execute code before or after the request reaches the route handler, enabling you to perform common tasks such as authentication, logging, error handling, and more.
• Built-in support for TypeScript. Fastify has excellent support for TypeScript out of the box. It provides type definitions, decorators, and interfaces that enhance the development experience and help catch errors at compile-time
• HTTP/2 support. Fastify natively supports the HTTP/2 protocol, which enables faster and more efficient communication between clients and servers. This feature can significantly improve the performance of your web applications
• Plugin system. Fastify's plugin system allows you to selectively enable only the features and functionality required for your application. This modular approach helps reduce the overhead of unused features and keeps the core framework lightweight and focused
• Serialization and deserialization. Fastify provides a built-in serialization and deserialization mechanism that allows you to efficiently convert data between different formats (e.g., JSON, XML, MessagePack). This enables fast and optimized data transformations without the need for external libraries
• Stream support. Fastify has excellent support for streaming data, allowing you to efficiently handle large payloads or perform operations on chunks of data. By leveraging streams, Fastify can process and transmit data incrementally, reducing memory consumption and improving overall performance.
• Validation. Fastify promotes the use of JSON schema validation for incoming requests. It has built-in integration with JSON schema validators like AJV, allowing for efficient validation and parsing of request payloads.
• Efficient routing. Fastify utilizes a Radix Tree data structure for routing, which provides efficient and optimized routing of incoming requests. The Radix Tree reduces lookup time for routes, ensuring that request handling is faster and more efficient than traditional linear route matching used by many frameworks.

Radix Tree in Fastify

A radix tree, or compact prefix tree, plays a pivotal role in Fastify's architecture. It allows the framework to handle routes more efficiently by organizing them in a hierarchical structure. This means that Fastify can resolve the correct route for a request much quicker than linear search methods, significantly boosting the application's overall performance.

Fastify vs. Express: A Comparative Analysis

Fastify VS Express: Latency (GET health check)

autocannon -c 10000 -d 10 / 71k requests in 10.9s, 12.9 MB read / 5k errors (5k timeouts) - Express autocannon -c 10000 -d 10 / 153k requests in 10.89s, 24.7 MB read - Fastify

Fastify VS Express: Requests/second (GET health check)

autocannon -c 10000 -d 10 / 71k requests in 10.9s, 12.9 MB read / 5k errors (5k timeouts) - Express autocannon -c 10000 -d 10 / 153k requests in 10.89s, 24.7 MB read - Fastify

Fastify VS Express: Latency (GET list of entities)

autocannon -c 10000 -d 10 / 21k requests in 10.94s, 97.2 MB read / 48 errors (48 timeouts) - Express autocannon -c 10000 -d 10 / 24k requests in 11.36s, 121 MB read - Fastify

Fastify VS Express: Requests/second (GET list of entities)

autocannon -c 10000 -d 10 / 21k requests in 10.94s, 97.2 MB read / 48 errors (48 timeouts) - Express autocannon -c 10000 -d 10 / 24k requests in 11.36s, 121 MB read - Fastify

Routing differences with Express

1. Route Matching Efficiency: Fastify's radix tree-based routing engine allows for faster route matching compared to Express' linear pattern matching approach. With a radix tree, the routing engine can quickly navigate the tree and identify the appropriate route based on the URL pattern.

2. Performance with Large Number of Routes: As the number of routes in an application grows, Fastify's radix tree-based routing becomes increasingly advantageous. The radix tree structure provides better scalability and performance as it minimizes the time complexity for route matching, resulting in faster request handling.

3. Reduced Middleware Overhead: Fastify's routing engine eliminates the need for iterating through multiple middleware for each route. Instead, it can directly access the appropriate route handler, reducing the middleware lookup time and improving overall performance.

4. Memory Efficiency: The radix tree structure optimizes memory usage by storing shared prefixes of routes only once. This makes the radix tree more memory-efficient compared to maintaining an array or hash table of routes, as done in Express.

Fastify Hooks and middleware

Fastify hooks and middleware are both mechanisms provided by the Fastify framework for extending the functionality of your application. However, there are some key differences between them:

1. Execution Order: Middleware functions in Fastify are executed in the order they are registered, whereas hooks have a predefined order based on the request lifecycle stages. Hooks provide more granular control over the execution flow of your application.

2. Context and Scoping: Middleware functions in Fastify have access to the request and response objects, but they are not bound to a specific lifecycle stage. In contrast, hooks in Fastify are specifically associated with a particular lifecycle stage and have access to a scoped context, allowing you to share data and state within that stage.

3. Middleware Reusability: Fastify middleware functions can be reused across multiple routes or applications. You can apply middleware globally or selectively to specific routes. Hooks, on the other hand, are more tightly coupled to the request lifecycle and are typically used within the scope of a specific route or plugin.

4. Error Handling: Fastify middleware can handle errors by invoking the next() function with an error parameter. In contrast, Fastify hooks have dedicated error hooks like onRequest, onResponse, etc., which are executed when an error occurs within the respective lifecycle stage.

Fastify Plugin System 

Advantages of Fastify's Plugin System:

1. Modularity: Plugins promote code organization and reusability by encapsulating functionality into separate modules.

2. Encapsulation: Plugins have their own isolated scope, reducing conflicts and allowing for cleaner code separation. 

3. Extensibility: Plugins can be easily added or removed from the application without affecting other parts of the codebase. 

4. Dependency Injection: Fastify provides a built-in dependency injection system that allows plugins to register and share dependencies.

5. Flexibility: Fastify's plugin system provides fine-grained control over how plugins interact with the application, allowing for customization and configuration.

Disadvantages of Fastify's Plugin System:

1. Learning Curve: Understanding how to create and use Fastify plugins may require some initial learning and familiarity with Fastify's concepts.

2. Ecosystem Size: While Fastify has a growing ecosystem of plugins, it may not have the same breadth and depth of available plugins as Express.

3. Compatibility: Not all Express middleware and libraries are readily available as Fastify plugins, so you may need to adapt or create custom plugins for specific functionality.

Useful links

Fastify docs

Nestjs performance (Fastify) 

Radix Tree

Fastify routing 

Fastify hooks

Fastify middleware 

Fastify streaming

Fastify benchmarks 

Fastify ecosystem 

Fastify plugins

Fastify benchmark video 

Fastify benchmark video 2 

Fastify benchmark repository

Fastify represents a modern and efficient approach to web development in Node.js, tailored for applications that demand high performance and scalability. While Express remains a viable option for many, the architectural choices and features of Fastify make it an enticing alternative for projects where speed and efficiency are paramount. Whether you're building APIs, microservices, or any high-performance application, Fastify provides a robust foundation to develop on.