How does schema validation work in MongoDB?

Question

Accepted Answer

While MongoDB is flexible by default, it supports **schema validation** at the database level — defining rules (required fields, types, value constraints) that documents must satisfy. This adds data integrity *within* MongoDB itself (not just in application code), balancing flexibility with consistency.

## Defining validation rules

```js
// add a JSON Schema validator when creating (or modifying) a collection
db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "email"],            // required fields
      properties: {
        name: { bsonType: "string" },
        email: { bsonType: "string", pattern: "^.+@.+$" },   // type + pattern
        age: { bsonType: "int", minimum: 0, maximum: 120 }   // range
      }
    }
  }
});
// → documents that don't satisfy this are REJECTED on insert/update
```

MongoDB uses **JSON Schema** to define validation rules — required fields, types, patterns, ranges — enforced by the database when documents are inserted or updated.

## Validation levels and actions

```js
db.runCommand({
  collMod: "users",
  validator: { $jsonSchema: { ... } },
  validationLevel: "moderate",     // "strict" (all) or "moderate" (only valid existing docs)
  validationAction: "error"        // "error" (reject) or "warn" (log but allow)
});
```

`validationLevel` controls which documents are checked; `validationAction` controls whether violations error (reject) or just warn.

## Why validate in the database (vs only the app)?

```text
✓ DATABASE-LEVEL guarantee — enforced regardless of which app/code writes data
  (multiple services, scripts, manual changes) → consistent data integrity
✓ A safety net even if application validation is bypassed or buggy
→ Similar reasoning to SQL constraints: the DB is the last line of defense for integrity.
```

## Balancing flexibility and structure

```text
MongoDB's flexibility is valuable, but UNCONTROLLED flexibility → inconsistent data.
Schema validation lets you add structure WHERE you need it:
  → enforce critical fields/types while keeping flexibility elsewhere
  → start flexible, add validation as the schema stabilizes
(Often validation is also/instead done in the app layer, e.g. via Mongoose schemas.)
```

## Why it matters

Understanding MongoDB schema validation is valuable for **balancing MongoDB's flexibility with data integrity**, so it's useful knowledge for building reliable MongoDB applications.

While MongoDB's schema-less flexibility is a major advantage (suiting evolving and varied data), **uncontrolled flexibility can lead to inconsistent data** (missing fields, wrong types, invalid values) — a real concern for data quality.

Schema validation addresses this by letting you enforce rules (required fields, types, patterns, ranges via JSON Schema) **at the database level**, so documents must satisfy them.

The key value of **database-level validation** (as opposed to only application-level) is that it's enforced regardless of which application, service, script, or manual operation writes the data — providing a consistent integrity guarantee and a safety net even if application validation is bypassed or buggy (the same reasoning as SQL constraints: the database as the last line of defense).

Understanding the **validation levels and actions** (controlling which documents are checked and whether violations reject or warn) allows flexible adoption.

Most importantly, understanding how to **balance flexibility and structure** — adding validation where consistency matters while keeping flexibility elsewhere, often starting flexible and adding validation as the schema stabilizes — reflects mature MongoDB usage that gets the benefits of flexibility without sacrificing critical data integrity.

Knowing that validation is often done in the app layer too (e.g. Mongoose schemas) is also relevant.

Since data integrity matters even in flexible databases, and since MongoDB's schema validation lets you enforce structure where needed (at the database level for a strong guarantee) while preserving flexibility, understanding schema validation — how it works, database-level enforcement benefits, and balancing flexibility with structure — is valuable, practically-relevant knowledge for building MongoDB applications that maintain data quality, a useful capability that addresses the common concern of inconsistent data in flexible-schema databases.