The Undeniable Gospel of Performance
The primary reason engineers are drawn to Fastify is its raw, benchmark-crushing speed. In many tests, it handles two to five times more requests per second than Express. This isn't a fluke; it's by design. Fastify was built from the ground up for low
overhead, using a highly efficient radix-tree based router and an architecture that minimizes work done on each request. For developers building microservices, real-time APIs, or any system where latency and server costs are critical, this performance is a game-changer. Senior engineers who have battled scaling issues with other frameworks see Fastify not just as faster, but as a more efficient and sustainable foundation for high-throughput applications. The promise is simple: handle more traffic with fewer resources.
Schema: A Double-Edged Sword
Where the love-hate dynamic truly begins is with Fastify’s insistence on using JSON Schemas for validation and serialization. Proponents see this as a massive win for reliability and security. By defining the shape of incoming requests and outgoing responses upfront, you catch bad data at the door, prevent common vulnerabilities, and automatically generate documentation. Fastify pre-compiles these schemas, making validation incredibly fast. However, engineers accustomed to the freewheeling nature of Express often view this as restrictive and verbose. For them, the mandatory schema feels like bureaucratic boilerplate, slowing down prototyping and simple projects. This friction represents a core philosophical divide: do you prefer guardrails that enforce structure or the freedom to move quickly without them?
The Plugin Architecture Divide
Fastify’s extensibility model is another point of contention. Unlike the global middleware chain in Express, Fastify uses an encapsulated plugin system. Each plugin creates an isolated scope, preventing the kind of unpredictable side effects that can plague a large Express application. Supporters love this for building clean, modular, and maintainable systems. However, this is also where developers hit a learning curve. The Express ecosystem is vast and familiar; almost any functionality can be added with a simple `app.use()`. Fastify requires a different mindset. While an adapter exists to use Express middleware, it can degrade performance and adds complexity. This means migrating a legacy app is non-trivial, and some developers find the plugin model unintuitive compared to the straightforward middleware pattern they've used for years.
A Clash of Engineering Philosophies
Ultimately, the split opinion on Fastify isn't about features; it's about two conflicting development philosophies. Senior engineers who love Fastify prioritize long-term maintainability, performance at scale, and architectural rigor. They see the upfront investment in schemas and plugins as a crucial discipline that pays dividends in stability and efficiency. They are building for the long haul. On the other side, engineers who prefer the simplicity of Express often prioritize development velocity and flexibility. They argue that in many applications, the true bottleneck is the database or complex business logic, not the framework's routing speed. For them, the unopinionated nature of Express allows them to build faster and adapt more easily, making it the right tool for a huge range of projects where peak performance isn't the only metric that matters.
