Crea un backend rapido con ExpressJS

Arranqué este video porque muchas veces queremos levantar un backend para una idea o un MVP y nos perdemos en “boilerplates” gigantes. Acá voy a lo simple: Express puro, estructura clara y decisiones mínimas para salir andando en minutos. Esto es lo que vengo usando y me funciona para iterar rápido sin hipotecar el futuro del proyecto.

¿Por qué Express y para quién?

• Porque es minimalista: vos elegís las piezas.
• Ideal para MVPs, APIs internas, webhooks, servicios chicos y medianos.
• Si después querés escalar, la estructura ya te queda ordenada.

La estructura mínima que uso

Me gusta separar la app del server, y tener rutas, controladores y middlewares en carpetas aparte. Algo así:

project/
├─ package.json
├─ .env
└─ src/
   ├─ app.js
   ├─ server.js
   ├─ routes/
   │  └─ index.js
   ├─ controllers/
   │  └─ health.controller.js
   ├─ middlewares/
   │  └─ notFound.js
   └─ config/
      └─ env.js

Dependencias base

• Producción: express, cors, morgan, dotenv
• Dev: nodemon

Comandos rápidos:

npm i express cors morgan dotenv
npm i -D nodemon

En package.json:

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

app.js y server.js separados

Mantenerlos separados te deja testear la app sin levantar el server y facilita el escalado.

src/app.js:

const express = require('express');
const morgan = require('morgan');
const cors = require('cors');

const routes = require('./routes');
const notFound = require('./middlewares/notFound');

const app = express();

app.use(cors());
app.use(express.json());
app.use(morgan('dev'));

app.use('/api', routes);

app.use(notFound);

module.exports = app;

src/server.js:

require('dotenv').config();
const app = require('./app');

const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {
  console.log(`Servidor escuchando en http://localhost:${PORT}`);
});

Rutas y controladores simples

src/routes/index.js:

const { Router } = require('express');
const { health } = require('../controllers/health.controller');

const router = Router();

router.get('/health', health);

module.exports = router;

src/controllers/health.controller.js:

function health(req, res) {
  res.json({ ok: true, uptime: process.uptime() });
}

module.exports = { health };

Middleware de 404

src/middlewares/notFound.js:

module.exports = (req, res, next) => {
  res.status(404).json({ error: 'Ruta no encontrada' });
};

Variables de entorno

En .env:

PORT=3000
NODE_ENV=development

Y un pequeño helper por si querés centralizar:
src/config/env.js:

module.exports = {
  port: process.env.PORT || 3000,
  nodeEnv: process.env.NODE_ENV || 'development',
};

¿Qué queda para el próximo?

El manejo de errores. Es un tema grande: middlewares de error, categorías, códigos HTTP, logging y respuestas consistentes. Lo vemos a fondo en la próxima parte del minicurso.

Video

Abajo te dejo el episodio completo para que lo veas paso a paso.

Bonus: desplegar rápido

Si querés llevar esto a producción en minutos, tengo un video donde muestro cómo desplegar con Ubuntu + Docker. Te puede salvar si estás validando una idea rápido:
https://www.youtube.com/watch?v=Hz_Jr2I_n8w&ab_channel=CodigoMate

Gracias por bancar del otro lado. Si te sirvió, dejá un like y contame en comentarios qué querés ver en las próximas partes del minicurso de Express. Abrazo grande y nos vemos en el próximo, que viene con errores… pero bien manejados.