MongoDB Academy · Lesson

Databases, Collections, and Namespaces

Learners will create a database, add collections, and understand how MongoDB organises data at the namespace level.

Databases, Collections, and Namespaces is a free MongoDB Academy lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the MongoDB Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

MongoDB's Three-Level Hierarchy

MongoDB nests data in three levels: Database, Collection, Document. It mirrors SQL's database, table, row — and one server can hold many of each.

What Is a Namespace?

A namespace names a collection by combining database and collection with a dot, like myapp.users. You'll see this notation in logs and explain output.

// Namespace: database.collection
// 'shop' database, 'products' collection:
use shop
db.products.find({})
// MongoDB internally refers to this as 'shop.products'

// You can also reference it explicitly:
db.getSiblingDB('shop').getCollection('products').find({})

Switching and Creating Databases

In mongosh, use switches databases. There's no CREATE DATABASE — MongoDB makes one lazily, the moment you insert your first document. The code shows it.

// Switch to (or create) a database
use myNewApp
// 'myNewApp' doesn't exist yet - no error, but not visible in 'show dbs'

// Insert a document to materialize the database
db.users.insertOne({ name: 'Alice' });

// Now 'myNewApp' appears:
show dbs
// admin     0.000GB
// local     0.000GB
// myNewApp  0.000GB

System Databases: admin, local, config

MongoDB keeps three system databases: admin for users and roles, local for replication data, and config for sharded-cluster metadata. Good to recognize, not to touch.

// View all databases on the server
show dbs
// admin   0.000GB
// config  0.000GB
// local   0.004GB
// shop    0.012GB
// myapp   0.008GB

// List databases programmatically
db.adminCommand({ listDatabases: 1 });

Creating Collections Explicitly

Use createCollection when you need special options up front — capped, time-series, clustered, or a schema validator. The code creates one with validation rules.

// Create a collection with a JSON Schema validator
db.createCollection('products', {
  validator: {
    $jsonSchema: {
      bsonType: 'object',
      required: ['name', 'price'],
      properties: {
        name:  { bsonType: 'string' },
        price: { bsonType: 'number', minimum: 0 }
      }
    }
  }
});

Listing and Inspecting Collections

A few commands let you explore your database: list collections, get detailed info, and check storage stats. show collections is the quick one. The code shows more.

use shop

show collections
// orders
// products
// users

db.getCollectionInfos();
// Returns array of {name, type, options, idIndex} per collection

db.orders.stats().count;
// 15234

db.orders.totalIndexSize();
// 2359296 (bytes)

Renaming and Dropping Collections

You can rename a collection instantly, or drop one to delete it for good. Dropping is permanent — there's no recycle bin, so back up first in production.

// Rename a collection
db.oldUsers.renameCollection('users');
// { ok: 1 }

// Drop a collection - IRREVERSIBLE
db.tempData.drop();
// true

// Drop the entire database - EXTREMELY DANGEROUS
// db.dropDatabase();
// Use only in development or with full backup

Multi-Tenancy With Databases

For SaaS apps, multi-tenancy can mean a database per customer for strong isolation, or one shared collection filtered by a tenantId field. The code shows both.

// Option 1: Database-per-tenant
const db = client.db('tenant_' + tenantId);
db.users.find({});
// Each tenant has completely isolated data

// Option 2: Shared collection with tenantId field
const db = client.db('saas_app');
db.users.find({ tenantId: tenantId });
// All tenants share one collection, filtered by tenantId

Collection Naming Best Practices

A few naming habits prevent headaches: stay consistent, use plural nouns like users, and avoid special characters. Good naming conventions make code easier to read.

// Good collection names
db.users.find({});
db.order_items.find({});
db.productCategories.find({});

// Avoid these
db['$sales'].find({});        // $ prefix causes issues
db['system.logs'].find({});   // reserved prefix
db['my.collection'].find({}); // dot in name causes confusion

The WiredTiger Storage Engine

MongoDB's default storage engine is WiredTiger. It allows many writes at once without blocking, compresses data on disk, and journals writes so crashes don't lose data.

// Check current storage engine
db.serverStatus().storageEngine;
// { name: 'wiredTiger', supportsCommittedReads: true, ... }

// Collection stats show compression savings
db.orders.stats();
// storageSize: 2097152 (compressed on disk)
// size: 8388608 (uncompressed logical size)

Understanding the Oplog

The oplog is a special log of every write in a replica set. Secondaries replay it to stay in sync, and it also powers MongoDB's live Change Streams.

// Inspect oplog in mongosh (replica set members only)
use local
db.oplog.rs.find().sort({ $natural: -1 }).limit(3);
// { op: 'i', ns: 'shop.orders', o: { _id: ..., ... } }
// op: 'i'=insert, 'u'=update, 'd'=delete, 'c'=command

Quick Check

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

Lesson Recap

You learned MongoDB organizes data as Database, Collection, Document, that databases are created lazily, and that WiredTiger powers storage. Next: the mongosh shell.

Frequently asked questions

Is the “Databases, Collections, and Namespaces” lesson free?

Yes — the full text of “Databases, Collections, and Namespaces” is free to read here on the web, and the MongoDB Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the MongoDB Academy course, upgrade to CoddyKit PRO.

What will I learn in “Databases, Collections, and Namespaces”?

Learners will create a database, add collections, and understand how MongoDB organises data at the namespace level. You practise MongoDB Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start MongoDB Academy?

No prior experience is required. MongoDB Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Databases, Collections, and Namespaces” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this MongoDB Academy lesson?

Yes. Every MongoDB Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to MongoDB Academy