I’ve been building APIs for years, and I keep coming back to a simple truth: the fastest code is the code that never runs. Think about it. If you can stop a bad request before it even touches your database or business logic, you save processing time, prevent errors, and keep your system secure. This is why I’m so focused on validation. Recently, I’ve been working with Fastify, a framework built for speed, and pairing it with Joi, a tool for defining exactly what your data should look like. The result is an API that’s not just quick, but also incredibly tough and reliable. Let’s look at how this works.
Fastify is designed from the ground up to be fast. It has a clever plugin system, low overhead, and automatic JSON parsing. It even validates data for you using JSON Schema. But sometimes, writing JSON Schema can feel a bit verbose. This is where Joi comes in. Joi lets you describe your data rules with a clean, readable syntax. It feels more like writing plain English than configuring a schema. By bringing Joi into Fastify, we get the best of both worlds: raw speed and a delightful way to define our rules.
So, how do we make them work together? Fastify has a concept called “decorators.” We can use these to add Joi’s power directly to the framework. First, we set up the integration. We install the necessary packages: fastify and joi. Then, we write a small piece of code to teach Fastify how to use Joi for validation.
const fastify = require('fastify')({ logger: true });
const Joi = require('joi');
// Teach Fastify to use Joi
fastify.decorate('joi', Joi);With that one line, fastify.joi is now available anywhere in our application. But the real magic happens when we define a route. Let’s say we’re building an endpoint to register a new user. We need to make sure the incoming data is correct. What happens if someone sends a username that’s too short, or an email that’s not valid?
Here’s how we define the validation for that route using our new tool.
const userSchema = fastify.joi.object({
username: fastify.joi.string().alphanum().min(3).max(30).required(),
email: fastify.joi.string().email().required(),
birthYear: fastify.joi.number().integer().min(1900).max(2023),
role: fastify.joi.string().valid('user', 'admin').default('user')
});
fastify.post('/user', {
schema: {
body: userSchema
}
}, async (request, reply) => {
// By the time we get here, the request.body is guaranteed to be valid.
const newUser = request.body;
// Your business logic to save the user goes here.
reply.code(201).send({ id: 123, ...newUser });
});See how readable that is? The schema clearly states: a username must be an alphanumeric string between 3 and 30 characters, the email must be valid, and so on. When a request hits this route, Fastify uses the Joi schema to check the request.body. If the data is wrong, Fastify automatically sends a detailed 400 Bad Request error back to the client. Our route handler code only runs for good data. This is that “fast code” principle in action.
But what about more complex rules? Joi really shines here. Let’s say you want to validate that a password and a password confirmation field match. Or that a discount code is only required if a user is not a premium member. Can your validation handle that?
Joi makes conditional logic straightforward. Here’s an example where we check that two fields are equal.
const changePasswordSchema = fastify.joi.object({
password: fastify.joi.string().min(8).required(),
confirmPassword: fastify.joi.string().valid(fastify.joi.ref('password')).required()
}).with('password', 'confirmPassword');The .valid(fastify.joi.ref('password')) line means “this field must have the same value as the ‘password’ field.” The .with() method ensures that if a password is provided, a confirmation must also be present. This declarative style is powerful. It moves complex logic out of our main function and into a clear, testable schema.
The benefits of this setup are huge for building and maintaining an application. First, performance. Fastify’s validation is blisteringly fast, and Joi is highly optimized. This check happens early in the request lifecycle, saving precious milliseconds on invalid requests. Second, security. It acts as a first line of defense, sanitizing input before it’s used in database queries or other operations. Third, developer experience. These schemas live right next to your routes. They serve as perfect, up-to-date documentation for what your API expects. When I come back to a route six months later, I can understand the rules instantly.
I encourage you to think about your own API endpoints. Where are you manually checking data in your controller functions? Could those checks be moved to a clear, central schema? The shift in mindset—from checking data inside your logic to defining rules at the door—makes your code cleaner, safer, and easier to reason about.
Getting started is simple. Create a new Fastify project, install Joi, and add that one decorator line. Try converting one of your existing routes. Define a schema for the request body and watch as Fastify handles the validation for you. You’ll immediately notice your route handler becomes simpler. It only contains the core business task, free from messy data-checking if statements.
This combination has fundamentally changed how I build reliable services. It allows me to move fast without cutting corners on data integrity. The confidence that every piece of incoming data has been vetted against a strict set of rules is invaluable. It leads to fewer bugs, clearer code, and a more robust application overall.
If you’re building APIs with Node.js, I strongly suggest giving Fastify and Joi a try. Start with a simple route and see how it feels to offload validation. Did this approach change how you think about structuring your endpoints? Share your thoughts in the comments below—I’d love to hear about your experiences. If you found this useful, please like and share it with other developers who might be wrestling with API validation. Let’s build faster, safer software together.
As a best-selling author, I invite you to explore my books on Amazon. Don’t forget to follow me on Medium and show your support. Thank you! Your support means the world!
101 Books
101 Books is an AI-driven publishing company co-founded by author Aarav Joshi. By leveraging advanced AI technology, we keep our publishing costs incredibly low—some books are priced as low as $4—making quality knowledge accessible to everyone.
Check out our book Golang Clean Code available on Amazon.
Stay tuned for updates and exciting news. When shopping for books, search for Aarav Joshi to find more of our titles. Use the provided link to enjoy special discounts!
📘 Checkout my latest ebook for free on my channel!
Be sure to like, share, comment, and subscribe to the channel!
Our Creations
Be sure to check out our creations:
Investor Central | Investor Central Spanish | Investor Central German | Smart Living | Epochs & Echoes | Puzzling Mysteries | Hindutva | Elite Dev | JS Schools
We are on Medium
Tech Koala Insights | Epochs & Echoes World | Investor Central Medium | Puzzling Mysteries Medium | Science & Epochs Medium | Modern Hindutva
