I Got Tired of Repeating Validation Logic in Every Node.js Project — So I Built Zero Validation

mr.z_fullstack — Tue, 09 Jun 2026 12:25:59 +0000

How I Published My Own Validation Package on npm

As developers, we've all done this:

if (!email) {
  throw new Error("Email is required");
}

if (typeof email !== "string") {
  throw new Error("Email must be a string");
}

if (!email.includes("@")) {
  throw new Error("Invalid email");
}

Now imagine doing this for:

User Registration
Login APIs
Product Creation
Payment Requests
Admin Panels
Microservices

The validation code starts growing faster than the actual business logic.

The Problem

In many Node.js projects, validation ends up being:

Repetitive
Hard to maintain
Inconsistent across APIs
Difficult to scale

Every endpoint contains similar checks:

if (!name) ...
if (!email) ...
if (!password) ...
if (password.length < 8) ...

As projects grow, these validations become scattered throughout the codebase.

Existing Solutions

There are already some excellent validation libraries available:

Zod
Joi
Yup
Express Validator

I've used many of them and they're great.

But for some smaller projects and APIs, I wanted something:

Lightweight
Easy to understand
Minimal setup
Zero configuration
TypeScript friendly

That's what led me to build Zero Validation.

Introducing Zero Validation

Zero Validation is a lightweight schema validation package for Node.js and TypeScript applications.

The goal is simple:

Define your validation schema once and validate data consistently everywhere.

Installation

npm install zero-validation

Basic Example

import { z } from "zero-validation";

const userSchema = z.object({
  name: z.string(),
  email: z.email(),
  age: z.number(),
});

const result = userSchema.parse({
  name: "John",
  email: "john@example.com",
  age: 25,
});

console.log(result);

Handling Validation Errors

const result = userSchema.safeParse(data);

if (!result.success) {
  console.log(result.errors);
}

Instead of crashing your application, you can safely inspect validation errors and return meaningful API responses.

Why I Built It

This project started as a learning exercise.

I wanted to understand:

How schema validation libraries work internally
TypeScript type inference
Package publishing
Open-source maintenance

What started as a simple experiment eventually became a reusable package that can be installed directly from npm.

What I Learned While Building It

Building an npm package taught me much more than validation itself.

Some lessons:

1. API Design Matters

Developers prefer:

schema.parse(data);

over

validateDataAgainstSchemaUsingCustomFunction(data);

Small API decisions have a huge impact on usability.

2. Documentation Is Part of the Product

A package without documentation is almost impossible to adopt.

Writing examples, README files, and usage guides often takes longer than writing the code itself.

3. Error Messages Matter

Developers spend most of their time fixing errors.

Good validation libraries provide clear and actionable feedback.

Future Improvements

Some features I'm planning to add:

Custom validators
Nested schemas
Array validation
Async validation
Better TypeScript inference
Express middleware integration

Open Source Feedback Welcome

This project is still evolving, and I'd love feedback from the developer community.

Questions I'd love to hear:

What validation features do you use most?
What do you dislike about existing validation libraries?
What would make a lightweight validation library more useful?

If you'd like to check out the project, feel free to try it and share your thoughts.

💡 Quick Links

📦 npm Package:
https://www.npmjs.com/package/zero-validation

Happy coding :)

DEV Community: mr.z_fullstack