The Backend Setup Every Developer Should Follow

Before you write your backend code, it is very important to have a clean and organized setup — one that helps you scale, debug, and collaborate better.

There are 6 major layers of it.

1. Routes


2. Controllers


3. Middleware


4. Services


5. Repositary


6. Database

Routes – The Entry Points

Routes define which function should run when a specific request hits your server.

They map HTTP methods and URLs to controllers.

router.post("/signup", userController.signup);

router.get("/profile", authMiddleware, userController.getProfile);

Routes should be thin and clean.

They don’t contain logic.

They only decide where the request goes.

Think of Routes as:

The road map of your backend.

Controllers – The Request Handlers

Controllers handle:

• Reading request data (req.body, req.params, req.query)


• Sending response (res.json, res.status)


• Calling the service layer

They should NOT:

• Contain business logic


• Talk directly to the database


• Hash passwords


• Calculate business rules

Think of Controllers as:

The receptionist. They receive and respond.

Middleware – The Gatekeepers

Middleware runs before the controller.

It is used for:

• Authentication (JWT verification)


• Logging


• Input validation


• Rate limiting


• Error handling
  

router.get("/profile", authMiddleware, userController.getProfile);

The request must pass through middleware before reaching the controller.

Think of Middleware as:

The security check at the airport.

Services – The Brain of the Application

This is where your real logic lives.

Services handle:

• Business rules


• Data transformations


• Workflow decisions

Orchestration of multiple repositories.

exports.signup = async ({ email, password }) => {

  const existingUser = await userRepository.findByEmail(email);



  if (existingUser) {

    throw new Error("User already exists");

  }



  const hashedPassword = await bcrypt.hash(password, 10);



  return await userRepository.createUser(email, hashedPassword);

};

Think of Services as:

The decision-maker.

Repository – The Data Access Layer

The repository is responsible for:

• Communicating with the database


• Executing queries


• Returning raw data

It does NOT:

• Decide business rules


• Validate logic


• Handle HTTP
  

exports.findByEmail = async (email) => {

  return db("users").where({ email }).first();

};

Repository is:

An abstraction over the database.

If tomorrow you switch from PostgreSQL to MongoDB,

only the repository layer should change.

Think of Repository as:

The translator between your app and the database.

Database – The Storage Engine

This is your:

• PostgreSQL


• MySQL


• MongoDB


• Supabase

Its job is simple:

• Store data


• Retrieve data


• Maintain integrity

It does not care about:

• HTTP


• Business logic


• Application rules


• It only stores information

Full Request Flow

• Let’s say a user signs up.


• Request hits Route


• Middleware validates token/input


• Controller receives request


• Controller calls Service


• Service applies business logic


• Service calls Repository


• Repository talks to Database


• Response travels back up the chain

Database → Repository → Service → Controller → Client

Clean. Predictable. Scalable.

🧠 Simple Mental Model

If you're ever confused where something belongs, ask:

Does it handle HTTP? → Controller

Does it validate/authenticate/log? → Middleware

Is it business logic? → Service

Is it database query? → Repository

Is it storage? → Database

Does it map endpoint to controller? → Route

This structure is inspired by architectural principles popularized in

Clean Architecture by Robert C. Martin — but simplified for practical backend applications.