🧪"Bro, Does This API Even Work?" — Building & Testing a Real Node.js + MongoDB Backend

🛠️ From Messy to Mastery: Structuring Your Node.js Backend Like a Pro

Yaksh Bhesaniya

NextGen Dev Labs

· ~4 min read · April 11, 2025 (Updated: April 12, 2025) · Free: No

🚧 Warning: This blog involves serious backend building. No fluff, no TODO apps, and definitely no res.send('Hello from 2015').

👋 Welcome back, backend bestie! In Part 1, we Marie-Kondo'ed your folder structure and kicked index.js chaos out the door. Now it's time to build something real — an actual working API that:

✅ Talks to MongoDB ✅ Validates user input ✅ Doesn't blow up in Postman ✅ Actually does what APIs are supposed to do

We're skipping the fluff. No "Hello World", no fake To-Do apps. This is the real-world stuff — the kind of backend you'd actually use in a side project, freelance gig, or startup hustle.

Let's go from "where do I even start?" to "yo, it just worked on the first try!"

🛠️ What We're Building Today

A simple (but real) API:

POST /users → Create a user
GET /users/:id → Get a user by ID
MongoDB for storage
Zod for input validation
Express + TypeScript stack
Tested in Postman (because cURL gives me trust issues)

🗂️ File Setup Recap (Quick Refresher)

From Part 1, we're working in this structure:

/src
 ┣ /features
 ┃ ┣ /users
 ┃ ┃ ┣ user.controller.ts
 ┃ ┃ ┣ user.service.ts
 ┃ ┃ ┣ user.routes.ts
 ┃ ┃ ┣ user.model.ts
 ┃ ┃ ┣ user.validators.ts
 ┃ ┃ ┗ index.ts
 ┃ ┣ /auth
 ┃ ┃ ┣ auth.controller.ts
 ┃ ┃ ┣ auth.service.ts
 ┃ ┃ ┣ auth.routes.ts
 ┃ ┃ ┣ auth.strategy.ts
 ┃ ┃ ┗ index.ts
 ┃ ┗ ...more features (posts, payments, unicorns 🦄)
 ┣ /shared
 ┃ ┣ /middlewares
 ┃ ┣ /utils
 ┃ ┣ /constants
 ┃ ┗ /types
 ┣ /config
 ┃ ┣ env.config.ts
 ┃ ┗ db.config.ts
 ┣ /core
 ┃ ┣ app.ts
 ┃ ┗ server.ts
 ┣ /tests
 ┃ ┣ /unit
 ┃ ┗ /integration
 ┗ index.ts

🔗 Step 1: Connect MongoDB Like an Adult

In /config/db.config.ts:

import mongoose from 'mongoose';

export const connectDB = async () => {
  try {
    await mongoose.connect(process.env.MONGO_URI!);
    console.log('✅ MongoDB connected');
  } catch (err) {
    console.error('❌ MongoDB connection error:', err);
    process.exit(1);
  }
};

Now plug it in core/server.ts:

import { connectDB } from '../config/db.config';
connectDB();

.env

MONGO_URI=mongodb://localhost:27017/backend_besties

Yes, please use .env. Don't make me find your hardcoded passwords on GitHub.

👤 Step 2: Create a User Schema

In /features/users/user.model.ts:

import mongoose from 'mongoose';

const UserSchema = new mongoose.Schema(
  {
    name: { type: String, required: true },
    email: { type: String, required: true, unique: true },
  },
  { timestamps: true }
);
export default mongoose.model('User', UserSchema);

Short. Sweet. Gets the job done.

🧠 Step 3: Add Zod for Input Validation

Install it:

npm i zod

In /features/users/user.validators.ts:

import { z } from 'zod';

export const createUserSchema = z.object({
  name: z.string().min(1, "Name is required"),
  email: z.string().email("Invalid email"),
});

And then use it in your controller.

📥 Step 4: Controller + Service Logic

In /features/users/user.controller.ts:

import { Request, Response } from 'express';
import * as userService from './user.service';
import { createUserSchema } from './user.validators';

export const createUser = async (req: Request, res: Response) => {
  try {
    const data = createUserSchema.parse(req.body);
    const user = await userService.create(data);
    res.status(201).json(user);
  } catch (err: any) {
    res.status(400).json({ error: err.message });
  }
};

export const getUserById = async (req: Request, res: Response) => {
  try {
    const user = await userService.findById(req.params.id);
    if (!user) return res.status(404).json({ error: 'User not found' });
    res.json(user);
  } catch (err: any) {
    res.status(400).json({ error: err.message });
  }
};

In /features/users/user.service.ts:

import User from '../../models/User';

export const create = async (data: { name: string; email: string }) => {
  return await User.create(data);
};

🛣️ Step 5: Plug It into Routes

In /features/users/user.routes.ts:

import express from 'express';
import * as controller from './user.controller';

const router = express.Router();
router.post('/', controller.createUser);
router.get('/:id', controller.getUserById);

export default router;

Then import this into /core/app.ts:

import userRoutes from '../features/users/user.routes';

app.use('/users', userRoutes);

Boom. You just built an actual backend endpoint.

🧪 Step 6: Test Like a Pro in Postman

POST http://localhost:5000/users

{
  "name": "Yaksh",
  "email": "yaksh@example.com"
}

GET http://localhost:5000/users/{user_id}

✅ Check responses ❌ Break stuff on purpose (send invalid email) 🎉 Throw party when validation saves your backend from bad data

⚠️ Common Mistakes to Avoid

Skipping validation because "frontend handles it" (spoiler: it won't)
Not using .env files (and leaking secrets to GitHub)
Writing controller + DB logic in one file like it's 2012
Not handling errors (aka user goes poof and no one knows why)

🔮 What's Next in the Series?

Next up: we'll add authentication (because right now, any random human can hit /users and we're not about that life).

We'll cover:

JWT auth
Login/Register APIs
Securing routes like a backend bouncer 🧢🕶️

🤝 Let's Be Backend Besties

If this helped even a little, smash that follow button on Medium, drop a comment, or send me a cookie emoji 🍪. Want the next post in your inbox? 👉 Subscribe here Let's build better backends, together. 🙌

✍️ This post is part 2 of my series: