Bouw een eenvoudige takenmanager met categorieën met Node.js en MongoDB

Een simpele to-dolijst werkt in het begin prima: je voegt wat taken toe en kunt ze afsluiten zodra je klaar bent. Maar naarmate het aantal taken toeneemt, wordt het lastig in gebruik. Eén ding dat dit kan oplossen is categorisatie toevoegen, zodat elke taak kan behoren tot categorieën zoals Werk, Studie, Persoonlijk, enz., en je de lijst kunt filteren op de categorie die je nodig hebt.

In deze tutorial leer je hoe je een REST-API bouwt waarmee je taken per categorie kunt organiseren met Node.js en MongoDB. Aan het eind heb je een werkende Node.js-server met vijf endpoints: create, list, get, update en delete, plus een categoriefilter. Je ziet ook hoe je categorievalidatie afdwingt met de native MongoDB-driver, zonder te vertrouwen op een ODM zoals Mongoose.

Wat je gaat leren

• Hoe je een REST-API bouwt met Node.js, Express en MongoDB, inclusief volledige CRUD-endpoints
• Hoe je invoer valideert, categorieën afdwingt en ObjectId-waarden veilig en effectief afhandelt
• Hoe je je API structureert en test en deze vervolgens koppelt aan een frontend

Je kunt de complete code voor deze tutorial op GitHub vinden als je liever kloont en meeleest terwijl je gaat.

Vereisten

Voordat je begint, heb je het volgende nodig:

• Node.js 18+ geïnstalleerd (npm is standaard inbegrepen)
• MongoDB lokaal draaiend, of een gratis MongoDB Atlas-cluster
• Postman of een andere HTTP-client
• Basiskennis van JavaScript en REST-concepten

Stap 1: Zet het project op

Laten we onze eenvoudige takenmanager gaan bouwen. Het eerste wat we doen is een nieuwe map maken en een Node-project initialiseren door onderstaande commando’s in onze terminal uit te voeren:

mkdir task-manager-categories
cd task-manager-categories
npm init -y

Vervolgens installeren we de vier runtime-afhankelijkheden die onze app nodig heeft om te draaien: express voor routing, de officiële MongoDB-driver, dotenv voor het laden van omgevingsvariabelen, en tot slot helmet voor security headers.

npm install express mongodb dotenv helmet

Installeer voor development nodemon als dev-dependency met onderstaand commando, zodat de server automatisch herlaadt wanneer bestanden veranderen:

npm install --save-dev nodemon

Open daarna de projectmap in je IDE en werk de sectie scripts in package.json bij om het volgende op te nemen. Hiermee kun je de server starten met npm start of in developmentmodus draaien met npm run dev:

"scripts": {
  "start": "node server.js",
  "dev": "nodemon server.js"
}

Hier is de structuur die we gaandeweg opbouwen. Elke map heeft een duidelijke rol: db/ beheert de databaseverbinding, lib/ bevat helperfuncties, middleware/ is voor Express-middleware en routes/ definieert de requesthandlers. De map public/ bevat een kleine frontend die we later toevoegen. Zelfs in een klein project houdt deze structuur alles overzichtelijk en is het duidelijk waar nieuwe code hoort. Voel je vrij om de mappenstructuur nu al aan te maken en gaandeweg te vullen, of sla dit over en voeg elk bestand toe terwijl we de stappen doorlopen:

task-manager-categories/
├── db/
│ └── connect.js
├── lib/
│ └── taskDocument.js
├── middleware/
│ └── parseObjectId.js
├── routes/
│ └── tasks.js
├── public/
│ ├── index.html
│ ├── styles.css
│ └── app.js
├── .env
├── .env.example
├── .gitignore
├── package.json
└── server.js

Stap 2: Verbind met MongoDB

Om taken op te slaan en op te halen, moeten we onze app eerst verbinden met MongoDB. Dit gebeurt met een connection string, die de MongoDB-driver vertelt hoe hij met je database moet verbinden. In plaats van die rechtstreeks in je code te hardcoderen, kun je deze beter in een omgevingsbestand bewaren. Zo houd je gevoelige waarden uit je codebase en kun je makkelijker tussen omgevingen wisselen.

Maak een bestand .env.example om de vereiste variabelen te documenteren, en een .env voor je echte waarden, als volgt:

# Copy this file to `.env` and fill in real values.

# --- Local MongoDB ---
# Use this if you're running MongoDB locally
MONGO_URI=mongodb://127.0.0.1:27017

# --- MongoDB Atlas ---
# Replace <username>, <password>, and <cluster-url> with your actual values
# Example: mongodb+srv://user:pass@cluster0.abcde.mongodb.net/
# MONGO_URI=mongodb+srv://<username>:<password>@<cluster-url>/?retryWrites=true&w=majority

DB_NAME=taskmanager
PORT=3000

Nu we een connection string hebben, kunnen we die gebruiken om onze MongoDB-verbinding op te zetten. Maak een bestand db/connect.js. Hier initialiseren we de MongoDB-client en maken we die beschikbaar voor de rest van de app:

const { MongoClient } = require("mongodb");

let client;
let db;

async function connectDB() {
  if (!process.env.MONGO_URI) {
    throw new Error("MONGO_URI is not set. Check your .env file.");
  }
  client = new MongoClient(process.env.MONGO_URI, {
    appName: "devrel-tutorial-javascript-crud-geeksforgeeks",
  });
  await client.connect();
  db = client.db(process.env.DB_NAME || "taskmanager");
  await db.collection("tasks").createIndex({ category: 1 });

  console.log(`MongoDB connected (db: ${db.databaseName})`);
}

function getTasksCollection() {
  if (!db) {
    throw new Error("Database not initialized. Call connectDB() first.");
  }
  return db.collection("tasks");
}

async function closeDB() {
  if (client) await client.close();
}

module.exports = { connectDB, getTasksCollection, closeDB };

Dit bestand zet één MongoDB-client op die de rest van de app kan hergebruiken. Je wilt dit maar één keer aanmaken, omdat de driver onder water al verbindingen poolt. Voor elke request een nieuwe client maken lijkt misschien prima, maar veroorzaakt al snel prestatieproblemen.

Stap 3: Definieer de taakstructuur en validatie

Op dit punt kan de app verbinding maken met MongoDB. Nu moeten we definiëren hoe een taak er precies uitziet voordat we iets opslaan.

Hier voelt het gebruik van de native MongoDB-driver wat anders. Er is geen schemabestand zoals bij Mongoose. In plaats daarvan is het “schema” simpelweg de vorm van het object dat je in de database stopt. Dat voelt in het begin misschien wat losjes, maar is juist handig omdat je dicht bij de echte werking van MongoDB blijft en er niets schuilgaat achter abstracties.

We willen nog steeds validatie. In plaats van die logica over verschillende routes te verspreiden, houden we het op één plek zodat alles dezelfde regels volgt. Maak een bestand genaamd lib/taskDocument.js en voeg onderstaande code toe:

class ValidationError extends Error {
  constructor(message) {
    super(message);
    this.name = 'ValidationError';
  }
}

const ALLOWED_CATEGORIES = ['Work', 'Personal', 'Study', 'Other'];

function assertValidCategory(category) {
  if (!ALLOWED_CATEGORIES.includes(category)) {
    throw new ValidationError(
      `category must be one of: ${ALLOWED_CATEGORIES.join(', ')}`
    );
  }
}

function buildTaskDocument(body = {}) {
  if (!body.title || typeof body.title !== 'string' || !body.title.trim()) {
    throw new ValidationError('title is required and must be a non-empty string');
  }
  if (body.category != null) {
    assertValidCategory(body.category);
  }
  const now = new Date();
  return {
    title: body.title.trim(),
    description: typeof body.description === 'string' ? body.description.trim() : '',
    category: body.category != null ? body.category : 'Other',
    completed: Boolean(body.completed),
    createdAt: now,
    updatedAt: now
  };
}

function buildTaskUpdate(body = {}) {
  const updates = {};
  if (typeof body.title === 'string' && body.title.trim()) {
    updates.title = body.title.trim();
  }
  if (typeof body.description === 'string') {
    updates.description = body.description.trim();
  }
  if (body.category != null) {
    assertValidCategory(body.category);
    updates.category = body.category;
  }
  if (body.completed != null) {
    updates.completed = Boolean(body.completed);
  }
  if (Object.keys(updates).length === 0) {
    throw new ValidationError('no valid fields provided for update');
  }
  updates.updatedAt = new Date();
  return updates;
}

module.exports = {
  ALLOWED_CATEGORIES,
  buildTaskDocument,
  buildTaskUpdate,
  ValidationError
};

Dit bestand fungeert als poortwachter voor alles wat je database ingaat. Elke create- of updateaanvraag gaat hierlangs, zodat je op één plek de regels afdwingt.

Het zorgt ervoor dat taken altijd de juiste vorm hebben, categorieën consistent blijven en voorkomt verrassingen later bij het query’en van je data. De custom ValidationError geeft je ook een nette manier om slechte input te onderscheiden van echte serverproblemen, zodat je API passend kan reageren. Met dit alles op zijn plek kan de rest van de app eenvoudig blijven. Elke route kan zich richten op zijn eigen taak, in de wetenschap dat de data die binnenkomt al geldig is. Vervolgens koppelen we de routes en beginnen we taken op te slaan in MongoDB.

Stap 4: ObjectId en requestvalidatie afhandelen

Nu we weten hoe een taak eruitziet, gaan we regelen hoe we ernaar verwijzen. Telkens wanneer een route een :id-parameter bevat, komt die binnen als een gewone string. Maar MongoDB verwacht een ObjectId. Als die string onjuist is, gooit de driver een vrij onduidelijke fout. In plaats van dat in elke route af te handelen, centraliseren we het met middleware zodat elke endpoint zich hetzelfde gedraagt.

Maak hiervoor een bestand genaamd middleware/parseObjectId.js en voeg het volgende toe:

const { ObjectId } = require('mongodb');

function parseObjectId(req, res, next) {
  const { id } = req.params;
  if (!ObjectId.isValid(id)) {
    return res.status(400).json({ error: 'invalid task id' });
  }
  req.taskId = new ObjectId(id);
  next();
}

module.exports = parseObjectId;

Deze middleware draait vóór je routehandler. Hij controleert of de id geldig is, zet die om naar een ObjectId en hangt die aan req.taskId. Zo werk je, zodra je routelogica draait, altijd met een geldige ObjectId en worden slechte inputs vroegtijdig afgewezen met een duidelijke 400-response. Vervolgens pluggen we dit in onze routes en verbinden we alles.

Stap 5: Bouw de taakroutes (CRUD + filteren)

Op dit punt is het meeste zware werk al gedaan. We hebben gedefinieerd hoe een geldige taak eruitziet en geregeld hoe ID’s worden geparst en gevalideerd. Dat betekent dat onze routehandlers zich op één ding kunnen richten: praten met de database.

Laten we de daadwerkelijke API-routes bouwen door een bestand genaamd routes/tasks.js te maken en het volgende toe te voegen:

const express = require('express');
const { getTasksCollection } = require('../db/connect');
const {
  ALLOWED_CATEGORIES,
  buildTaskDocument,
  buildTaskUpdate,
  ValidationError
} = require('../lib/taskDocument');
const parseObjectId = require('../middleware/parseObjectId');

const router = express.Router();

// POST /tasks
router.post('/', async (req, res, next) => {
  try {
    const doc = buildTaskDocument(req.body);
    const result = await getTasksCollection().insertOne(doc);
    res.status(201).json({ _id: result.insertedId, ...doc });
  } catch (err) {
    if (err instanceof ValidationError) {
      return res.status(400).json({ error: err.message });
    }
    next(err);
  }
});

// GET /tasks (optionally ?category=Work)
router.get('/', async (req, res, next) => {
  try {
    const { category } = req.query;
    if (category && !ALLOWED_CATEGORIES.includes(category)) {
      return res.status(400).json({
        error: `category must be one of: ${ALLOWED_CATEGORIES.join(', ')}`
      });
    }
    const filter = category ? { category } : {};
    const tasks = await getTasksCollection()
      .find(filter)
      .sort({ createdAt: -1 })
      .toArray();
    res.json(tasks);
  } catch (err) { next(err); }
});

// GET /tasks/:id
router.get('/:id', parseObjectId, async (req, res, next) => {
  try {
    const task = await getTasksCollection().findOne({ _id: req.taskId });
    if (!task) return res.status(404).json({ error: 'task not found' });
    res.json(task);
  } catch (err) { next(err); }
});

// PUT /tasks/:id
router.put('/:id', parseObjectId, async (req, res, next) => {
  try {
    const updates = buildTaskUpdate(req.body);
    const result = await getTasksCollection().findOneAndUpdate(
      { _id: req.taskId },
      { $set: updates },
      { returnDocument: 'after' }
    );
    if (!result) return res.status(404).json({ error: 'task not found' });
    res.json(result);
  } catch (err) {
    if (err instanceof ValidationError) {
      return res.status(400).json({ error: err.message });
    }
    next(err);
  }
});

// DELETE /tasks/:id
router.delete('/:id', parseObjectId, async (req, res, next) => {
  try {
    const result = await getTasksCollection().deleteOne({ _id: req.taskId });
    if (result.deletedCount === 0) {
      return res.status(404).json({ error: 'task not found' });
    }
    res.status(204).end();
  } catch (err) { next(err); }
});

module.exports = router;

Elke route in de bovenstaande code volgt hetzelfde patroon: input uit het request ophalen, door de helpers halen die we eerder bouwden, MongoDB aanroepen en vervolgens een response teruggeven. Met validatie en ID-parsing al afgehandeld, blijft de code hier klein en voorspelbaar. In de praktijk werkt het zo:

• De POST-route bouwt een nieuwe taak met buildTaskDocument voordat die wordt ingevoegd
• De GET-routes filteren optioneel op categorie en geven resultaten terug gesorteerd op nieuwste eerst
• De PUT-route gebruikt buildTaskUpdate, dus gedeeltelijke updates zijn veilig en consistent
• De DELETE-route verwijdert een taak op basis van de al geparste ObjectId

Er zijn ook nog wat andere details in deze code het vermelden waard:

• find() retourneert een cursor, geen array, dus we chainen .toArray() na het sorteren om daadwerkelijk de resultaten te krijgen
• findOneAndUpdate met returnDocument: 'after' geeft je meteen het bijgewerkte document
• We geven de juiste HTTP-statuscodes terug: 201 voor create, 204 voor delete, en 400 of 404 waar passend
• Onverwachte fouten worden doorgegeven aan next(err), zodat ze op één plek worden afgehandeld in plaats van in elke route

Stap 6: Koppel alles in de server

Op dit punt zijn alle onderdelen aanwezig. We hebben validatie, schone routes en een werkende databaseverbinding. Nu hoeven we alles alleen nog te koppelen en de server daadwerkelijk te starten. Maak een bestand server.js. Dit is het toegangspunt van de app, waar alles samenkomt:

require('dotenv').config();

const path = require('path');
const express = require('express');
const helmet = require('helmet');
const { connectDB, closeDB } = require('./db/connect');
const tasksRouter = require('./routes/tasks');

if (!process.env.MONGO_URI) {
  console.error('Fatal: MONGO_URI is not set. Copy .env.example to .env and fill it in.');
  process.exit(1);
}

const PORT = Number(process.env.PORT) || 3000;

const app = express();

app.use(helmet());
app.use(express.json({ limit: '100kb' }));
app.use(express.static(path.join(__dirname, 'public')));

app.get('/health', (req, res) => {
  res.json({ status: 'ok', service: 'task-manager-with-categories' });
});
app.use('/tasks', tasksRouter);

app.use((req, res) => {
  res.status(404).json({ error: 'not found' });
});

app.use((err, req, res, next) => {
  if (err.type === 'entity.too.large') {
    return res.status(413).json({ error: 'payload too large' });
  }
  if (err.type === 'entity.parse.failed') {
    return res.status(400).json({ error: 'invalid JSON body' });
  }
  console.error(err);
  res.status(500).json({ error: 'internal server error' });
});

async function start() {
  try {
    await connectDB();
    const server = app.listen(PORT, () => {
      console.log(`Server running on http://localhost:${PORT}`);
    });

    const shutdown = () => {
      console.log('\nShutting down gracefully...');
      server.close(async () => {
        await closeDB();
        process.exit(0);
      });
      setTimeout(() => process.exit(1), 10_000).unref();
    };
    process.on('SIGINT', shutdown);
    process.on('SIGTERM', shutdown);
  } catch (err) {
    console.error('Failed to start server:', err);
    process.exit(1);
  }
}

if (require.main === module) {
  start();
}

module.exports = { app, start };

Dit bestand verbindt alles op een nette manier. Het controleert dat je omgevingsvariabelen gezet zijn voordat er iets draait, past basisbeveiliging toe met helmet en beperkt inkomende JSON zodat je app niet per ongeluk enorme payloads accepteert. Het serveert ook je map public/, zodat je frontend in dezelfde app kan draaien zonder aparte server.

Al je routes staan onder /tasks en alles wat niet matcht geeft een nette 404. Fouten worden op één plek afgehandeld in plaats van in elke route, wat het consistent en onderhoudbaar houdt. De databaseverbinding wordt opgezet voordat de server begint te luisteren, zodat je nooit requests accepteert vóór je klaar bent, en afsluiten gebeurt netjes zodat verbindingen goed worden gesloten.

Start nu alles en controleer of het werkt met npm run dev. Als alles goed gekoppeld is, zie je zoiets als dit:

MongoDB connected (db: taskmanager)
Server running on http://localhost:3000

Op dit punt is alles gekoppeld en draaiend! We hebben nu een volledig werkende API, dus laten we die testen.

Stap 7: Test de API-endpoints

Voordat je een UI bouwt, is het handig te bevestigen dat elk endpoint op zichzelf werkt. Dit maakt debuggen veel eenvoudiger, omdat je snel kunt zien of een probleem uit de API of de frontend komt. We gebruiken Postman (of een andere HTTP-client) en voeren een paar requests op volgorde uit. Elk request bouwt voort op de data uit de vorige stap.

Maak een taak aan: Stuur een POST-request met een titel, beschrijving en categorie. Als alles werkt, retourneert de API 201 Created met de nieuwe taak en het gegenereerde _id-veld.

POST http://localhost:3000/tasks
Content-Type: application/json

{
  "title": "Write GeeksForGeeks article",
  "description": "First draft by Friday",
  "category": "Work"
}

Maak er nog een paar aan: Voer hetzelfde POST-request uit met verschillende bodies, zodat je genoeg data hebt om lijstweergave en filteren te testen. Hierna heb je een kleine dataset om te bevragen.

{ "title": "Go for a run", "category": "Personal" }
{ "title": "Read MongoDB docs", "category": "Study" }
{ "title": "Buy groceries" } // category defaults to "Other"

Lijst met alle taken: Deze retourneert alle taken, gesorteerd op nieuwste eerst.

GET http://localhost:3000/tasks

Filter op categorie: Dit retourneert alleen de Werk-taken. De index die je eerder toevoegde, houdt deze query snel naarmate je data groeit.

GET http://localhost:3000/tasks?category=Work

Werk een taak bij: Gebruik de _id van een van de zojuist aangemaakte taken (je kunt die kopiëren uit de POST-response of uit het lijst-endpoint). Dit retourneert de bijgewerkte taak. Je hoeft alleen de velden te sturen die je wilt wijzigen, zodat gedeeltelijke updates eenvoudig blijven.

PUT http://localhost:3000/tasks/<paste-task-id-here>
Content-Type: application/json

{ "completed": true }

Verwijder een taak: Gebruik de _id van de taak die je wilt verwijderen. Dit retourneert 204 No Content. Als je dezelfde taak daarna opnieuw probeert op te halen, krijg je een 404 met "task not found".

DELETE http://localhost:3000/tasks/<paste-task-id-here>

Nu heb je bevestigd dat alle routes zich gedragen zoals verwacht. De API doet zijn werk, dus we kunnen nu een UI erbovenop bouwen.

Stap 8: Voeg een frontend toe om met de API te werken

Postman is ideaal om de API te verifiëren, maar het is leuker om te zien hoe het op een echte website werkt, dus voegen we wat frontendcode toe aan onze applicatie.

In plaats van hier grote HTML- en CSS-bestanden te plakken, heb ik de code in deze GitHub-repo gezet. Ga daarheen en kopieer de inhoud van index.html, styles.css en favicon.svg naar je map public/ in de projectroot. Sla de wijzigingen op en ga dan naar localhost:3000. Plak vervolgens onderstaande code in het bestand app.js:

const form = document.getElementById('task-form');
const titleEl = document.getElementById('title');
const descEl = document.getElementById('description');
const catEl = document.getElementById('category');
const errEl = document.getElementById('form-error');
const listEl = document.getElementById('task-list');
const emptyEl = document.getElementById('empty');
const filterEl = document.getElementById('filter');
const countEl = document.getElementById('task-count');

async function api(method, path, body) {
  const res = await fetch(path, {
    method,
    headers: body ? { 'Content-Type': 'application/json' } : {},
    body: body ? JSON.stringify(body) : undefined
  });

  if (res.status === 204) return null;

  const data = await res.json();
  if (!res.ok) throw new Error(data.error || `Request failed (${res.status})`);
  return data;
}

const fetchTasks = (category) =>
  api('GET', '/tasks' + (category ? `?category=${encodeURIComponent(category)}` : ''));

const createTask = (body) => api('POST', '/tasks', body);
const updateTask = (id, body) => api('PUT', `/tasks/${id}`, body);
const deleteTask = (id) => api('DELETE', `/tasks/${id}`);

function updateCount(tasks) {
  const active = tasks.filter((t) => !t.completed).length;
  const total = tasks.length;

  if (total === 0) {
    countEl.textContent = '';
    return;
  }

  const scope = filterEl.value ? ` in ${filterEl.value}` : '';
  countEl.textContent = `${total} tasks${scope} · ${active} active`;
}

function renderTask(task) {
  const li = document.createElement('li');
  li.className = 'task' + (task.completed ? ' completed' : '');

  const checkbox = document.createElement('input');
  checkbox.type = 'checkbox';
  checkbox.checked = task.completed;
  checkbox.addEventListener('change', () =>
    updateTask(task._id, { completed: checkbox.checked }).then(refresh)
  );

  const title = document.createElement('div');
  title.textContent = task.title;

  const badge = document.createElement('span');
  badge.textContent = task.category;

  const del = document.createElement('button');
  del.textContent = 'Delete';
  del.onclick = () => deleteTask(task._id).then(refresh);

  li.append(checkbox, title, badge, del);
  return li;
}

function render(tasks) {
  listEl.innerHTML = '';
  emptyEl.classList.toggle('hidden', tasks.length > 0);

  for (const task of tasks) {
    listEl.appendChild(renderTask(task));
  }

  updateCount(tasks);
}

async function refresh() {
  try {
    const tasks = await fetchTasks(filterEl.value);
    render(tasks);
  } catch (e) {
    errEl.textContent = e.message;
  }
}

form.addEventListener('submit', async (e) => {
  e.preventDefault();
  errEl.textContent = '';

  const title = titleEl.value.trim();
  if (!title) {
    errEl.textContent = 'Title is required.';
    return;
  }

  try {
    await createTask({
      title,
      description: descEl.value.trim(),
      category: catEl.value
    });

    form.reset();
    await refresh();
  } catch (e) {
    errEl.textContent = e.message;
  }
});

filterEl.addEventListener('change', refresh);

refresh();

De JavaScript-code is waar alles weer aansluit op de API die je eerder bouwde. Elke functie komt overeen met een van je routes, waardoor de frontend overzichtelijk blijft. Alle requests lopen ook via één api()-helper, zodat je fouten op één plek afhandelt in plaats van overal dezelfde logica te herhalen.

Filteren werkt door een querystring zoals ?category=Work mee te geven, wat direct aansluit op de backendlogica die je al toevoegde. Na het aanmaken, bijwerken of verwijderen van een taak haalt de app de nieuwste lijst weer op zodat de UI in sync blijft. De taakenteller is een klein detail, maar helpt de app levendiger aan te voelen tijdens gebruik.

Start je server nu opnieuw met npm run dev, en open daarna http://localhost:3000 om de Takenmanager te proberen. Voeg een paar taken toe, werk ze bij, wissel tussen categorieën en verwijder er ook een paar. Op dit punt zijn frontend en backend volledig verbonden en werken ze end-to-end samen.

Samenvatting

Gefeliciteerd! Je hebt vanaf nul een complete taakmanager-API gebouwd met Node.js, Express en MongoDB. Je hebt validatie afgehandeld, je routes klein gehouden en alles samengebracht tot een werkend systeem. Belangrijker nog: je bent dicht bij de werkelijke werking van MongoDB gebleven in plaats van die te verbergen achter abstracties. Vanaf hier kun je de app verder ontwikkelen richting productie.

Belangrijkste punten

• Middleware gebruiken en validatie centraliseren houdt je code schoon en voorspelbaar.
• De native MongoDB-driver geeft je controle zonder onnodige abstractie.
• Een goed gestructureerde API is eenvoudig uit te breiden tot een productieklare app.