DEV Community: Jean Duppont

Stop Writing Validation Code. Start Writing JSON

Jean Duppont — Thu, 29 Jan 2026 16:20:42 +0000

The Problem Every Developer Faces

You're building a form. Simple registration form. Email, password, done.

// Joi
const schema = Joi.object({
  email: Joi.string().email().required(),
  password: Joi.string().min(8).required()
});

Two weeks later:

"Hey, can we make password 12 characters for enterprise users?"

You: Opens IDE, modifies code, writes tests, creates PR, waits for review, deploys

Product Manager: "Actually, can we A/B test 10 vs 12 characters first?"

You: Screams internally

What If Validation Wasn't Code?
What if validation rules were just... data?

[
  {
    "name": "email",
    "validation": [
      { "rule": "required" },
      { "rule": "email" }
    ]
  },
  {
    "name": "password",
    "validation": [
      { "rule": "required" },
      { "rule": "minLength", "value": 8 }
    ]
  }
]

That's it. Pure JSON.

No imports. No code. No deployment.

Introducing: Template-Based Validation

import { Validator } from '@teonord/validator';

// Your data
const formData = {
  email: 'user@example.com',
  password: 'pass123'
};

// Your validation rules (can be from anywhere)
const template = await fetch('/api/validation-rules').then(r => r.json());

// Validate
const result = new Validator(formData).validateTemplate(template);

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

Notice what just happened:

✅ Validation rules fetched from API
✅ Zero code changes needed
✅ Rules can change without deployment
✅ Non-developers can modify rules

Real-World Game Changers

1. Multi-Tenant SaaS

Different customers, different rules.

// Enterprise customer: strict validation
const enterpriseTemplate = [
  {
    name: "password",
    validation: [
      { rule: "minLength", value: 16 },
      { rule: "alphaNumeric" }
    ]
  }
];

// Startup customer: relaxed validation
const startupTemplate = [
  {
    name: "password",
    validation: [
      { rule: "minLength", value: 8 }
    ]
  }
];

// Load based on tenant
const template = await getValidationTemplate(tenantId);
const result = new Validator(data).validateTemplate(template);

No code changes. No deployments. Just configuration.

2. Compliance & Regulations

GDPR in EU. Different rules in California. Different rules in Brazil.

// Load rules based on user location
const template = await getValidationForRegion(userCountry);

// EU template includes GDPR-specific validations
// California template includes CCPA requirements
// All without touching code

Compliance team updates rules → Changes go live immediately

3. A/B Testing Validation

Product wants to test if stricter validation improves data quality.

const template = experimentGroup === 'strict'
  ? await fetch('/templates/strict-validation.json')
  : await fetch('/templates/standard-validation.json');

const result = new Validator(data).validateTemplate(template);

Run experiments on validation rules. Measure impact. Iterate.
No engineering time wasted.

4. CMS-Driven Forms

Build an admin panel where product team configures validation.

// Admin creates form in CMS
// Defines validation rules via UI
// Rules saved as JSON in database

// Frontend fetches and applies
const formConfig = await api.getForm(formId);
const result = new Validator(formData).validateTemplate(formConfig.validation);

Product team owns validation. Engineering team builds once.

Built-In Internationalization

Every rule supports multiple languages out of the box.

{
  "name": "email",
  "validation": [
    {
      "rule": "required",
      "message": {
        "en": "Email is required",
        "es": "El email es requerido",
        "fr": "L'email est requis",
        "de": "E-Mail ist erforderlich"
      }
    }
  ]
}

One template. Multiple languages. Zero code duplication.

Nested Object Validation

Dot notation for deep validation.

[
  {
    "name": "user.profile.email",
    "validation": [
      { "rule": "email" }
    ]
  },
  {
    "name": "user.address.zipCode",
    "validation": [
      { "rule": "regex", "value": "^[0-9]{5}$" }
    ]
  }
]

Clean. Readable. No complex nesting.

Conditional Validation

Validate based on other field values.

[
  {
    "name": "payment_method",
    "validation": [
      { "rule": "required" },
      { "rule": "in", "value": ["credit_card", "paypal"] }
    ]
  },
  {
    "name": "credit_card_number",
    "validation": [
      {
        "rule": "requiredIf",
        "value": ["payment_method", "credit_card"]
      },
      {
        "rule": "minLength",
        "value": 16
      }
    ]
  }
]

Dynamic validation logic. Still just JSON.

Version Control for Validation

Track validation changes like any other data.

CREATE TABLE validation_templates (
  id UUID PRIMARY KEY,
  name VARCHAR(255),
  template JSONB,
  version INTEGER,
  created_at TIMESTAMP,
  created_by VARCHAR(255)
);

Audit trail:
Who changed validation rules?
When?
What changed?
Rollback to previous version instantly

The Architecture

┌──────────────────┐
│   Admin Panel    │ ← Product team configures rules
└────────┬─────────┘
         │
         ↓
┌──────────────────┐
│    Database      │ ← Store templates as JSON
└────────┬─────────┘
         │
         ↓
┌──────────────────┐
│   API Endpoint   │ ← Serve templates
└────────┬─────────┘
         │
         ↓
┌──────────────────┐
│  Frontend/API    │ ← Fetch & validate
└──────────────────┘

Separation of concerns:
Business logic (validation rules) = Configuration
Application logic (how to validate) = Code

Comparison: The Old Way vs The New Way

Changing Password Requirements

Old Way (Joi/Zod):

Open IDE
Find validation file
Modify code
Write tests
Create PR
Code review
Merge
Deploy
Monitor Time: 2-3 days People involved: 2-3 developers Risk: High (code changes)

New Way (@teonord/validator):

Update JSON in database
Done Time: 2 minutes People involved: 1 product manager Risk: Low (configuration change, instant rollback)

Real Production Example

// Lambda function
export const handler = async (event) => {
  const data = JSON.parse(event.body);

  // Load validation template from DynamoDB
  const template = await dynamodb.get({
    TableName: 'ValidationTemplates',
    Key: { formId: event.pathParameters.formId }
  });

  // Validate
  const result = new Validator(data).validateTemplate(template.rules);

  if (!result.isValid) {
    return {
      statusCode: 400,
      body: JSON.stringify({ errors: result.errors })
    };
  }

  // Process valid data
  await processForm(data);

  return {
    statusCode: 200,
    body: JSON.stringify({ success: true })
  };
};

Update validation rules → No deployment needed

Why This Matters

Traditional validation libraries:

Validation = Code
Changes require deployment
Developers are bottleneck
Hard to A/B test
No runtime flexibility

@teonord/validator templates:

Validation = Configuration
Changes are instant
Product team can iterate
Easy to experiment
Complete runtime flexibility

The Paradigm Shift

Stop thinking: "I need to write validation code"
Start thinking: "I need to configure validation rules"

Getting Started

npm install @teonord/validator

Create your first template:

[
  {
    "name": "email",
    "validation": [
      {
        "rule": "required",
        "message": { "en": "Email is required" }
      },
      {
        "rule": "email",
        "message": { "en": "Invalid email format" }
      }
    ]
  }
]

Use it:

import { Validator } from '@teonord/validator';

const template = require('./validation-template.json');
const result = new Validator(formData).validateTemplate(template);

That's it.

Advanced: Dynamic Rule Loading

class ValidationService {
  async validate(formId, data) {
    // Load from cache first
    let template = await redis.get(`validation:${formId}`);

    if (!template) {
      // Load from database
      template = await db.getValidationTemplate(formId);

      // Cache for 1 hour
      await redis.set(`validation:${formId}`, template, 'EX', 3600);
    }

    return new Validator(data).validateTemplate(template);
  }
}

Fast. Flexible. Cacheable.

Who Should Use This?

✅ SaaS platforms with multiple tenants
✅ Enterprise apps with complex compliance
✅ International products needing multi-language validation
✅ Rapid iteration teams doing A/B testing
✅ Low-code platforms where non-devs configure forms
✅ API-first architectures needing runtime flexibility

The Bottom Line

Validation rules change more often than your code.
So why are they in your code?

@teonord/validator's template API separates validation logic from application code.

Result:

Faster iteration
Less deployment risk
Product team autonomy
Better compliance
Easier A/B testing
True multi-tenancy

Try It Today

npm install @teonord/validator

Documentation: @teonord/qrdrobe

Stop deploying validation changes.
Start configuring them.

One More Thing

This isn't just about validation.
It's about rethinking what belongs in code vs configuration.
Validation rules are business logic.
Business logic changes frequently.
Frequently changing things shouldn't require deployments.
@teonord/validator gets this right.

What will you build when validation is just JSON?

Written by a developer who's tired of deploying validation changes.

Want to see this in action? Drop a comment and I'll show you a real production setup.

Give feedback to improve this answer.

Practical Next.js Form Validation with @teonord/validator

Jean Duppont — Sat, 18 Oct 2025 22:18:43 +0000

Form validation doesn't need to be complicated. In this tutorial, I'll show you how to implement clean, efficient form validation in Next.js using @teonord/validator with a real-world example.

Setting Up Our Project

First, install the package:

npm install @teonord/validator

Building a Contact Form with Smart Validation

Let's create a contact form that demonstrates the most common validation scenarios you'll encounter in real projects.

// components/ContactForm.tsx
'use client';

import { useState } from 'react';
import { Validator } from '@teonord/validator';

export default function ContactForm() {
  const [formData, setFormData] = useState({
    name: '',
    email: '',
    phone: '',
    subject: '',
    message: '',
    urgency: 'normal',
    agreeToTerms: false
  });

  const [errors, setErrors] = useState<Record<string, string>>({});

  const validationRules = {
    name: [{ rule: 'required' }],
    email: [
      { rule: 'required' },
      { rule: 'email' }
    ],
    phone: [
      { rule: 'requiredIf', value: ['urgency', 'urgent'] }
    ],
    subject: [
      { rule: 'required' },
      { rule: 'minLength', value: [5] }
    ],
    message: [
      { rule: 'required' },
      { rule: 'minLength', value: [10] },
      { rule: 'maxLength', value: [500] }
    ],
    urgency: [{ rule: 'required' }],
    agreeToTerms: [
      { rule: 'accepted' }
    ]
  };

  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();

    const validator = new Validator(formData);
    const result = validator.validateRules(validationRules);

    if (!result.isValid) {
      // Convert array errors to simple object
      const errorMap: Record<string, string> = {};
      Object.keys(result.errors).forEach(key => {
        if (result.errors[key].length > 0) {
          errorMap[key] = result.errors[key][0];
        }
      });
      setErrors(errorMap);
      return;
    }

    setErrors({});
    // Handle form submission
    console.log('Form submitted:', formData);
  };

  const handleChange = (field: string, value: any) => {
    setFormData(prev => ({ ...prev, [field]: value }));
    // Clear error when user starts typing
    if (errors[field]) {
      setErrors(prev => {
        const newErrors = { ...prev };
        delete newErrors[field];
        return newErrors;
      });
    }
  };

  return (
    <div className="max-w-lg mx-auto p-6 bg-white rounded-lg shadow-md">
      <h2 className="text-2xl font-bold mb-6">Contact Us</h2>

      <form onSubmit={handleSubmit} className="space-y-4">
        {/* Name Field */}
        <div>
          <label className="block text-sm font-medium mb-1">Full Name</label>
          <input
            type="text"
            value={formData.name}
            onChange={(e) => handleChange('name', e.target.value)}
            className={`w-full p-2 border rounded ${
              errors.name ? 'border-red-500' : 'border-gray-300'
            }`}
            placeholder="Enter your full name"
          />
          {errors.name && <p className="text-red-500 text-sm mt-1">Name is required</p>}
        </div>

        {/* Email Field */}
        <div>
          <label className="block text-sm font-medium mb-1">Email</label>
          <input
            type="email"
            value={formData.email}
            onChange={(e) => handleChange('email', e.target.value)}
            className={`w-full p-2 border rounded ${
              errors.email ? 'border-red-500' : 'border-gray-300'
            }`}
            placeholder="your@email.com"
          />
          {errors.email && (
            <p className="text-red-500 text-sm mt-1">
              {errors.email.includes('email') ? 'Invalid email format' : 'Email is required'}
            </p>
          )}
        </div>

        {/* Phone Field - Conditionally Required */}
        <div>
          <label className="block text-sm font-medium mb-1">
            Phone Number {formData.urgency === 'urgent' && <span className="text-red-500">*</span>}
          </label>
          <input
            type="tel"
            value={formData.phone}
            onChange={(e) => handleChange('phone', e.target.value)}
            className={`w-full p-2 border rounded ${
              errors.phone ? 'border-red-500' : 'border-gray-300'
            }`}
            placeholder="+1 (555) 123-4567"
          />
          {errors.phone && <p className="text-red-500 text-sm mt-1">Phone is required for urgent requests</p>}
        </div>

        {/* Urgency Selection */}
        <div>
          <label className="block text-sm font-medium mb-1">Urgency</label>
          <select
            value={formData.urgency}
            onChange={(e) => handleChange('urgency', e.target.value)}
            className="w-full p-2 border border-gray-300 rounded"
          >
            <option value="low">Low</option>
            <option value="normal">Normal</option>
            <option value="urgent">Urgent</option>
          </select>
        </div>

        {/* Subject Field */}
        <div>
          <label className="block text-sm font-medium mb-1">Subject</label>
          <input
            type="text"
            value={formData.subject}
            onChange={(e) => handleChange('subject', e.target.value)}
            className={`w-full p-2 border rounded ${
              errors.subject ? 'border-red-500' : 'border-gray-300'
            }`}
            placeholder="What is this regarding?"
          />
          {errors.subject && (
            <p className="text-red-500 text-sm mt-1">
              {errors.subject.includes('minLength') ? 'Subject must be at least 5 characters' : 'Subject is required'}
            </p>
          )}
        </div>

        {/* Message Field */}
        <div>
          <label className="block text-sm font-medium mb-1">Message</label>
          <textarea
            value={formData.message}
            onChange={(e) => handleChange('message', e.target.value)}
            rows={4}
            className={`w-full p-2 border rounded ${
              errors.message ? 'border-red-500' : 'border-gray-300'
            }`}
            placeholder="Please describe your inquiry..."
          />
          {errors.message && (
            <p className="text-red-500 text-sm mt-1">
              {errors.message.includes('minLength') && 'Message must be at least 10 characters'}
              {errors.message.includes('maxLength') && 'Message must be less than 500 characters'}
              {errors.message.includes('required') && 'Message is required'}
            </p>
          )}
          <div className="text-sm text-gray-500 text-right">
            {formData.message.length}/500
          </div>
        </div>

        {/* Terms Agreement */}
        <div className="flex items-center">
          <input
            type="checkbox"
            id="agreeToTerms"
            checked={formData.agreeToTerms}
            onChange={(e) => handleChange('agreeToTerms', e.target.checked)}
            className="mr-2"
          />
          <label htmlFor="agreeToTerms" className="text-sm">
            I agree to the terms and conditions
          </label>
        </div>
        {errors.agreeToTerms && <p className="text-red-500 text-sm">You must agree to the terms</p>}

        {/* Submit Button */}
        <button
          type="submit"
          className="w-full bg-blue-500 text-white py-2 px-4 rounded hover:bg-blue-600 transition-colors"
        >
          Send Message
        </button>
      </form>
    </div>
  );
}

Server-Side Validation in API Route

For complete security, always validate on the server too:

// app/api/contact/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { Validator } from '@teonord/validator';

export async function POST(request: NextRequest) {
  try {
    const body = await request.json();

    const validationRules = {
      name: [{ rule: 'required' }],
      email: [{ rule: 'required' }, { rule: 'email' }],
      phone: [{ rule: 'requiredIf', value: ['urgency', 'urgent'] }],
      subject: [{ rule: 'required' }, { rule: 'minLength', value: [5] }],
      message: [{ rule: 'required' }, { rule: 'minLength', value: [10] }],
      urgency: [{ rule: 'required' }],
      agreeToTerms: [{ rule: 'accepted' }]
    };

    const validator = new Validator(body);
    const result = validator.validateRules(validationRules);

    if (!result.isValid) {
      return NextResponse.json(
        { 
          success: false,
          errors: result.errors 
        },
        { status: 400 }
      );
    }

    // Process the form data (send email, save to database, etc.)
    console.log('Processing contact form:', body);

    // Simulate processing delay
    await new Promise(resolve => setTimeout(resolve, 1000));

    return NextResponse.json({ 
      success: true,
      message: 'Thank you for your message! We will get back to you soon.'
    });

  } catch (error) {
    return NextResponse.json(
      { success: false, error: 'Invalid JSON data' },
      { status: 400 }
    );
  }
}

Key Features Demonstrated

1. Conditional Validation

The phone field is only required when urgency is set to "urgent":

phone: [{ rule: 'requiredIf', value: ['urgency', 'urgent'] }]

2. Multiple Validation Rules

Single fields can have multiple rules:

email: [{ rule: 'required' }, { rule: 'email' }]

3. Length Validation

Control minimum and maximum lengths:

message: [
  { rule: 'required' },
  { rule: 'minLength', value: [10] },
  { rule: 'maxLength', value: [500] }
]

4. Checkbox Validation

Validate boolean values like terms agreement:

agreeToTerms: [{ rule: 'accepted' }]

Real-Time User Experience

The form provides immediate feedback:

Clear visual indicators for invalid fields
Dynamic error messages that disappear when users start correcting
Conditional requirements that change based on user selections
Character counting for length-limited fields

Best Practices for Production

Consistent Rules: Use the same validation rules on client and server
User-Friendly Messages: Provide clear, actionable error messages
Progressive Enhancement: Validate as users type, but always validate on submit
Security First: Never trust client-side validation alone

Conclusion

This approach gives you:

✅ Clean, readable validation rules
✅ Conditional logic without complex code
✅ Consistent client and server validation
✅ Great user experience with immediate feedback
✅ Type-safe validation with TypeScript

The @teonord/validator package makes form validation straightforward and maintainable, letting you focus on building great features instead of writing complex validation logic.

Ready to implement? Copy the code above and adapt it to your Next.js forms today!

What form validation challenges have you faced in your projects? Share your experiences in the comments!