Qué significa construir un SaaS por tu cuenta
Un producto de software como servicio parece, a primera vista, una aplicación web más. Sin embargo, en cuanto aparece el primer cliente que paga, el proyecto cambia de naturaleza: necesitas cuentas de usuario, aislamiento de datos entre organizaciones, correos que lleguen, errores que se registren, copias de seguridad, un dominio y una factura mensual de infraestructura que no te arruine. Todo eso recae en una sola persona cuando empiezas solo.
Este tutorial recorre las decisiones técnicas de un SaaS pequeño y mantenible, pensado para una persona o un equipo muy reducido. No hay una receta universal, así que el enfoque es explicar el porqué de cada pieza y mostrar el código mínimo que la sostiene. El stack elegido es deliberadamente aburrido: Node.js con Express 5 en el servidor, PostgreSQL como base de datos, Redis para sesiones y caché, y una aplicación de una sola página en el cliente construida con Vite y Preact.
Antes de empezar, conviene fijar las versiones de referencia. Node.js está en la línea 24 con soporte a largo plazo y la 26 ya ha entrado en su ciclo de vida más reciente, de modo que cualquiera de las dos sirve para este proyecto. Express 5 es hoy la versión por defecto en npm y PostgreSQL 18 es la rama estable más reciente. Para el cliente usaremos Vite en lugar de configurar Webpack a mano, porque la configuración manual de empaquetadores que fue habitual hace unos años ha quedado superada por herramientas con valores por defecto sensatos.
Los principios que guiarán todas las decisiones son cuatro. Primero, evitar la dependencia de un proveedor concreto: si mañana quieres cambiar de nube, no debería ser una reescritura. Segundo, mantener el código simple y legible, con pocas capas. Tercero, que el coste crezca con el uso y no antes. Cuarto, construir con responsabilidad: no recopilar datos que no necesitas, no esconder lo que haces con ellos y no diseñar mecanismos de adicción.
Elegir una idea que puedas sostener
La mejor fuente de ideas es un problema que tú mismo sufres con frecuencia. Si usas a diario una hoja de cálculo para repartir tareas, una carpeta compartida para aprobar documentos o un correo para pedir presupuestos, probablemente otras personas hacen lo mismo y pagarían por algo mejor. Tu ventaja es que conoces el flujo real, sus excepciones y sus pequeñas frustraciones.
Antes de escribir código, responde por escrito a tres preguntas. Quién es el usuario concreto, qué hace hoy para resolverlo y por qué eso no le basta. Si no puedes contestar con precisión, cualquier arquitectura que elijas será una apuesta a ciegas. Una buena prueba consiste en describir el producto en una frase sin usar la palabra «plataforma».
También es importante dimensionar el alcance. Un primer lanzamiento útil tiene pocas pantallas: registro, inicio de sesión, el flujo principal y una página de ajustes de cuenta. Todo lo demás, como roles avanzados, integraciones o paneles de analítica, puede esperar a que haya usuarios que lo pidan. Como orientación, si tu lista de funciones del primer lanzamiento supera la docena, recorta.
Decidir cómo se renderiza la interfaz
Hay tres grandes familias para construir la parte visible. La primera es la aplicación de una sola página, donde el navegador descarga un paquete de JavaScript y consume una API JSON. La segunda es el renderizado híbrido en servidor, que genera HTML en el servidor y luego «hidrata» el cliente. La tercera es la aplicación tradicional renderizada en servidor con algo de JavaScript espolvoreado encima.
Para un SaaS con mucha interacción, como tablas editables, arrastrar y soltar o edición de texto enriquecido, la aplicación de una sola página sigue siendo una opción muy razonable. Tiene una ventaja práctica enorme: el cliente es un conjunto de archivos estáticos que puedes servir desde un CDN barato, mientras que el servidor se limita a exponer una API. Las dos mitades se despliegan, escalan y fallan de forma independiente.
La contrapartida es el posicionamiento en buscadores y el rendimiento de la primera carga. Para esto, la solución es separar con claridad: la página de presentación y el blog se generan como HTML estático, y solo la aplicación autenticada es una SPA. Los buscadores no necesitan indexar lo que hay detrás del inicio de sesión.
Si prefieres una única tecnología de principio a fin, un framework de renderizado híbrido también funciona. Lo esencial no es la etiqueta, sino que entiendas qué se ejecuta dónde y qué cuesta cada elección. Si necesitas repasar cómo se monta un servidor y su despliegue, la guía cómo desplegar un sitio con Express 5 y Heroku paso a paso cubre la parte de publicación con más detalle.
Organizar el repositorio
Un monorepo con dos carpetas de primer nivel es suficiente. Un solo repositorio permite cambiar cliente y servidor en un mismo commit, y evita sincronizar versiones entre proyectos. No necesitas herramientas pesadas de gestión de monorepos para algo así.
mi-saas/
├── package.json
├── client/
│ ├── package.json
│ ├── vite.config.js
│ ├── index.html
│ └── src/
│ ├── main.jsx
│ ├── api.js
│ └── estilos/
└── server/
├── package.json
├── .env
└── src/
├── app.js
├── db.js
├── redis.js
├── logger.js
├── middleware/
└── rutas/
Mantén la estructura plana. Resiste la tentación de crear carpetas para cada concepto antes de tener varios archivos que las justifiquen. Un script en la raíz que lance ambas mitades en paralelo hace el desarrollo más cómodo.
{
"name": "mi-saas",
"private": true,
"scripts": {
"dev:client": "npm --prefix client run dev",
"dev:server": "npm --prefix server run dev",
"dev": "npm-run-all --parallel dev:client dev:server"
},
"devDependencies": {
"npm-run-all2": "^7.0.0"
}
}
Si no tienes claro cómo gestionar varias versiones de Node entre proyectos, la guía sobre cómo instalar y usar NVM para gestionar versiones de Node.js te ahorrará más de un problema. Añade además un archivo .nvmrc o el campo engines de package.json para que todos usen la misma versión.
El cliente: Vite, Preact y variables de entorno
Preact ofrece una API casi idéntica a la de React con una fracción del tamaño, lo que se nota en la primera carga. Con Vite, la configuración inicial se reduce a unas pocas líneas y obtienes recarga en caliente, división de código y compilación de producción optimizada sin configurar nada más.
// client/vite.config.js
import { defineConfig } from "vite";
import preact from "@preact/preset-vite";
export default defineConfig({
plugins: [preact()],
server: {
port: 5173,
proxy: {
"/api": "http://localhost:4000"
}
},
build: {
target: "es2022",
sourcemap: true
}
});
El proxy durante el desarrollo es un detalle valioso: el navegador cree que habla con un único origen, así que no tienes que lidiar con políticas de CORS mientras programas. En producción, como veremos más adelante, sí tendrás que decidir cómo resolver ese asunto.
Las variables de entorno del cliente se exponen con el prefijo VITE_ y quedan incrustadas en el paquete al compilar. Esto implica una regla de oro: nunca pongas ahí secretos. Todo lo que llega al navegador es público, incluidas las claves de servicios de terceros que no estén diseñadas para ser públicas.
// client/src/api.js
const BASE = import.meta.env.VITE_API_URL ?? "/api";
export async function pedir(ruta, opciones = {}) {
const respuesta = await fetch(`${BASE}${ruta}`, {
credentials: "include",
headers: { "Content-Type": "application/json" },
...opciones,
body: opciones.body ? JSON.stringify(opciones.body) : undefined
});
if (!respuesta.ok) {
const detalle = await respuesta.json().catch(() => ({}));
const error = new Error(detalle.mensaje ?? "Error de red");
error.estado = respuesta.status;
throw error;
}
return respuesta.status === 204 ? null : respuesta.json();
}
Un pequeño envoltorio sobre fetch como el anterior centraliza la gestión de errores, las cabeceras y las cookies. No necesitas una librería de peticiones para empezar, y cuando tu aplicación crezca será fácil sustituirlo.
Rendimiento web desde el primer día
Las páginas lentas pierden usuarios, y corregir el rendimiento al final es mucho más caro que cuidarlo desde el principio. Hay varias técnicas que dan resultados desproporcionados con muy poco esfuerzo.
La primera es la división de código. Cada ruta de la aplicación debería cargarse bajo demanda con importaciones dinámicas, de modo que el usuario que solo visita el inicio de sesión no descargue el editor de texto enriquecido.
import { lazy, Suspense } from "preact/compat";
const Tablero = lazy(() => import("./paginas/Tablero.jsx"));
const Ajustes = lazy(() => import("./paginas/Ajustes.jsx"));
export function Rutas({ ruta }) {
return (
<Suspense fallback={<p>Cargando…</p>}>
{ruta === "/ajustes" ? <Ajustes /> : <Tablero />}
</Suspense>
);
}
La segunda es el tratamiento de las fuentes. Servir tipografías desde tu propio dominio evita una conexión adicional a un tercero y mejora la privacidad. Además, puedes recortar el archivo de fuente a los caracteres que realmente usas y declarar font-display: swap para que el texto sea visible mientras la fuente se descarga.
La tercera es el CSS crítico. Los estilos mínimos para pintar la primera pantalla pueden ir en línea dentro del HTML, mientras que el resto se carga sin bloquear el renderizado. Los iconos funcionan muy bien como sprite SVG: un único archivo, cacheable, del que referencias cada símbolo por su identificador.
Por último, prueba siempre la compilación de producción en local antes de desplegar. El comando vite preview sirve los archivos generados tal como los vería un usuario real y revela problemas que el servidor de desarrollo oculta, como rutas relativas rotas o variables de entorno ausentes.
$ npm --prefix client run build
vite v7 building for production...
✓ 42 modules transformed.
dist/index.html 0.62 kB
dist/assets/index-a1b2c3.css 4.10 kB
dist/assets/index-d4e5f6.js 38.77 kB
✓ built in 1.1s
Diseño visual coherente sin sistemas complicados
No necesitas un sistema de diseño enorme, pero sí un conjunto reducido de decisiones repetibles. Define una escala modular para espaciados y tamaños de texto mediante propiedades personalizadas de CSS. Así evitas valores arbitrarios dispersos por la hoja de estilos.
:root {
--paso-0: 1rem;
--paso-1: 1.25rem;
--paso-2: 1.563rem;
--paso-3: 1.953rem;
--espacio-s: 0.5rem;
--espacio-m: 1rem;
--espacio-l: 2rem;
--color-primario: #1565c0;
--color-peligro: #c62828;
--color-texto: #212121;
}
.tarjeta {
display: flex;
flex-direction: column;
gap: var(--espacio-m);
padding: var(--espacio-l);
border-radius: 0.5rem;
}
Para el color, escoge una paleta ya probada en lugar de inventar la tuya. Una paleta con tonos numerados te da variantes claras y oscuras coherentes para fondos, bordes y estados. Para los estilos de componentes, los módulos CSS evitan colisiones de nombres sin añadir tiempo de ejecución, y Flexbox o Grid resuelven casi toda la maquetación.
Un consejo que paga con creces: estiliza primero las etiquetas HTML (button, input, table) y usa clases solo para las excepciones. Si cada botón es un botón decente por defecto, necesitarás muchas menos clases y el marcado quedará más limpio y accesible.
El servidor: Express 5 con una estructura mínima
Express 5 trae mejoras que importan en el día a día. La más relevante para nosotros es que los manejadores que devuelven una promesa rechazada envían el error automáticamente al middleware de errores. Esto vuelve obsoleto el paquete que antes se utilizaba para envolver cada ruta asíncrona, y el código resultante es más corto y más claro.
// server/src/app.js
import express from "express";
import helmet from "helmet";
import cors from "cors";
import { rutasCuentas } from "./rutas/cuentas.js";
import { manejarErrores } from "./middleware/errores.js";
export const app = express();
app.disable("x-powered-by");
app.use(helmet());
app.use(express.json({ limit: "100kb" }));
app.use(
cors({
origin: process.env.ORIGEN_CLIENTE,
credentials: true
})
);
app.get("/salud", (_req, res) => res.json({ ok: true }));
app.use("/api/cuentas", rutasCuentas);
app.use(manejarErrores);
Observa que limitamos el tamaño del cuerpo de las peticiones, ocultamos la cabecera que revela el framework y activamos las cabeceras de seguridad habituales mediante Helmet. Son medidas baratas que cierran vectores comunes. En un punto de entrada separado arrancamos el servidor, lo que facilita probar la aplicación sin abrir un puerto.
// server/src/index.js
import "dotenv/config";
import { app } from "./app.js";
import { log } from "./logger.js";
const puerto = Number(process.env.PORT ?? 4000);
app.listen(puerto, () => log.info({ puerto }, "Servidor escuchando"));
En el package.json del servidor, usa el modo de observación integrado de Node para reiniciar durante el desarrollo, y carga el archivo de entorno con la opción nativa si prefieres prescindir de dependencias. Para entender mejor las rutas y el middleware, puedes apoyarte en el tutorial completo de Express para desarrollo web.
PostgreSQL: pool de conexiones y SQL escrito a mano
PostgreSQL es una elección excelente para un SaaS: es robusto, está muy documentado, ofrece transacciones sólidas, tipos JSON cuando los necesitas y está disponible como servicio gestionado en prácticamente todos los proveedores. Si necesitas familiarizarte con la consola, la guía de psql en la terminal para administrar PostgreSQL es un buen complemento.
La conexión se gestiona con un pool, que reutiliza conexiones abiertas en lugar de crear una nueva por cada petición. Con el paquete pg necesitas poco código, y conviene exponer una función auxiliar para las transacciones, de forma que nunca olvides liberar el cliente.
// server/src/db.js
import pg from "pg";
export const pool = new pg.Pool({
connectionString: process.env.DATABASE_URL,
max: 10,
idleTimeoutMillis: 30_000
});
export const consulta = (texto, valores) => pool.query(texto, valores);
export async function transaccion(trabajo) {
const cliente = await pool.connect();
try {
await cliente.query("BEGIN");
const resultado = await trabajo(cliente);
await cliente.query("COMMIT");
return resultado;
} catch (error) {
await cliente.query("ROLLBACK");
throw error;
} finally {
cliente.release();
}
}
Hay un debate recurrente sobre si usar un ORM o escribir SQL directamente. Para un producto pequeño, escribir consultas a mano tiene ventajas claras: sabes exactamente qué se ejecuta, aprovechas funciones propias del motor como las expresiones de tabla comunes y evitas capas que ocultan problemas de rendimiento. A cambio, asumes la responsabilidad de parametrizar siempre las consultas, algo que no es negociable.
// Nunca concatenes valores del usuario en el texto SQL.
const { rows } = await consulta(
`SELECT id, titulo, creado_en
FROM proyectos
WHERE inquilino_id = $1 AND archivado = false
ORDER BY creado_en DESC
LIMIT $2`,
[inquilinoId, 50]
);
Las expresiones de tabla comunes ayudan a mantener consultas largas legibles al dividirlas en pasos con nombre. Por ejemplo, una consulta que calcula el total de tareas por proyecto y luego filtra los que superan cierto umbral se lee de arriba abajo, como un pequeño programa.
WITH conteo AS (
SELECT proyecto_id, COUNT(*) AS total
FROM tareas
WHERE inquilino_id = $1
GROUP BY proyecto_id
)
SELECT p.id, p.titulo, c.total
FROM proyectos p
JOIN conteo c ON c.proyecto_id = p.id
WHERE c.total > $2;
Modelar el esquema con criterio
Un esquema bien pensado evita la mayoría de los problemas futuros. Utiliza claves primarias estables, marcas de tiempo en todas las tablas y restricciones que expresen las reglas del negocio: claves foráneas, valores únicos y comprobaciones. Una restricción en la base de datos es una garantía que ningún error en el código puede romper.
CREATE TABLE inquilinos (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
nombre text NOT NULL,
creado_en timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE usuarios (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
inquilino_id bigint NOT NULL REFERENCES inquilinos(id) ON DELETE CASCADE,
email text NOT NULL,
clave_hash text NOT NULL,
verificado boolean NOT NULL DEFAULT false,
creado_en timestamptz NOT NULL DEFAULT now(),
UNIQUE (email)
);
CREATE INDEX idx_usuarios_inquilino ON usuarios (inquilino_id);
Desnormalizar de forma consciente es legítimo cuando una consulta frecuente lo exige, por ejemplo guardando un contador en la tabla padre en lugar de recalcularlo siempre. Eso sí, hazlo solo cuando hayas medido el problema. Para relaciones de muchos a muchos usa tablas intermedias con una clave primaria compuesta, y añade índices para las columnas por las que filtras o ordenas con frecuencia.
Para las migraciones, versiona cada cambio del esquema en archivos numerados y aplícalos con una herramienta sencilla. Nunca modifiques la base de producción a mano: cada cambio debe poder reproducirse desde cero en un entorno limpio.
Multi-inquilino con una única base de datos
Un SaaS atiende a varias organizaciones, y los datos de una nunca deben ser visibles para otra. Existen tres estrategias: una base de datos por cliente, un esquema por cliente o una base compartida con una columna que identifica al inquilino. Para un producto que empieza, la última es la más económica y la más fácil de operar.
El riesgo evidente es olvidar el filtro en alguna consulta, con consecuencias graves. La solución es hacerlo imposible de olvidar. PostgreSQL ofrece seguridad a nivel de fila, que aplica una política directamente en la base de datos, independientemente de lo que haga la aplicación.
ALTER TABLE proyectos ENABLE ROW LEVEL SECURITY;
CREATE POLICY aislamiento_inquilino ON proyectos
USING (inquilino_id = current_setting('app.inquilino_id')::bigint);
Con esta política, antes de ejecutar las consultas de una petición, la aplicación fija el valor de la variable de sesión dentro de la transacción. Si algún día una consulta olvida su filtro, la base de datos devolverá cero filas ajenas en lugar de filtrar datos entre clientes. Es una red de seguridad muy recomendable y, para una dependencia mínima, basta con un pequeño helper.
export async function conInquilino(inquilinoId, trabajo) {
return transaccion(async (cliente) => {
await cliente.query("SELECT set_config('app.inquilino_id', $1, true)", [
String(inquilinoId)
]);
return trabajo(cliente);
});
}
Recuerda que el usuario con el que se conecta la aplicación no debe ser el propietario de las tablas ni un superusuario, porque estos omiten las políticas por defecto. Crea un rol con permisos limitados para la aplicación.
Redis para sesiones y caché
Redis cumple aquí dos papeles diferentes. El primero es guardar las sesiones de usuario, que necesitan lecturas muy rápidas y expiración automática. El segundo es cachear resultados de consultas costosas, con una caducidad corta que evita datos obsoletos durante demasiado tiempo.
// server/src/redis.js
import { createClient } from "redis";
export const redis = createClient({ url: process.env.REDIS_URL });
redis.on("error", (error) => console.error("Redis", error));
await redis.connect();
export async function conCache(clave, segundos, obtener) {
const guardado = await redis.get(clave);
if (guardado) return JSON.parse(guardado);
const valor = await obtener();
await redis.set(clave, JSON.stringify(valor), { EX: segundos });
return valor;
}
El patrón anterior consulta primero la caché y, si no encuentra nada, calcula el valor y lo almacena. Hay una regla importante: la caché es una optimización, no una fuente de verdad. Tu aplicación debe seguir funcionando, aunque más despacio, si Redis no está disponible. Diseña las claves incluyendo el identificador del inquilino para no mezclar datos entre clientes, e invalida la entrada correspondiente cuando se modifiquen los datos de origen.
Autenticación con cookies de sesión
Para una aplicación web propia, con un único cliente de confianza, las sesiones con cookie son una opción más simple y más segura que los tokens firmados. La razón principal es la revocación: cerrar una sesión consiste en borrar una clave en Redis, algo inmediato, mientras que invalidar un token ya emitido es complicado. Si en cambio necesitas ofrecer una API a terceros, los tokens tienen sentido, y puedes consultar la guía para asegurar APIs REST de Node.js con JSON Web Tokens.
Las contraseñas nunca se guardan en claro. Utiliza un algoritmo de derivación diseñado para ello, como Argon2id o scrypt, con parámetros actuales. Node incluye scrypt en su módulo crypto, por lo que no necesitas dependencias nativas.
import { scrypt, randomBytes, timingSafeEqual } from "node:crypto";
import { promisify } from "node:util";
const derivar = promisify(scrypt);
export async function hashear(clave) {
const sal = randomBytes(16);
const derivada = await derivar(clave, sal, 64);
return `${sal.toString("hex")}:${derivada.toString("hex")}`;
}
export async function verificar(clave, almacenado) {
const [salHex, hashHex] = almacenado.split(":");
const derivada = await derivar(clave, Buffer.from(salHex, "hex"), 64);
return timingSafeEqual(derivada, Buffer.from(hashHex, "hex"));
}
La sesión se configura con express-session y un almacén en Redis. Las opciones de la cookie son críticas: marca la cookie como httpOnly para que el JavaScript del navegador no pueda leerla, como secure para que solo viaje por HTTPS y define sameSite para mitigar ataques de falsificación de peticiones.
import session from "express-session";
import { RedisStore } from "connect-redis";
import { redis } from "./redis.js";
app.set("trust proxy", 1);
app.use(
session({
store: new RedisStore({ client: redis, prefix: "sesion:" }),
secret: process.env.SECRETO_SESION,
resave: false,
saveUninitialized: false,
cookie: {
httpOnly: true,
secure: process.env.NODE_ENV === "production",
sameSite: "lax",
maxAge: 1000 * 60 * 60 * 24 * 14
}
})
);
Tras un inicio de sesión correcto, regenera el identificador de la sesión para evitar la fijación de sesiones. Aplica además límites de intentos en las rutas de acceso y registro, usando contadores en Redis, para frenar los ataques de fuerza bruta. Un mensaje de error genérico, que no revele si el correo existe, protege la privacidad de tus usuarios.
Validar entradas y centralizar los errores
Todo lo que llega del exterior es sospechoso hasta que se demuestre lo contrario. Valida cada cuerpo, parámetro y consulta en el borde de la aplicación. Puedes usar una librería de esquemas, como Zod, que además te da tipos si usas TypeScript.
import { z } from "zod";
const esquemaRegistro = z.object({
email: z.string().email().max(254),
clave: z.string().min(10).max(128),
nombreEmpresa: z.string().trim().min(2).max(80)
});
export function validar(esquema) {
return (req, _res, next) => {
const resultado = esquema.safeParse(req.body);
if (!resultado.success) {
return next(new ErrorHttp(422, "Datos no válidos", resultado.error.issues));
}
req.datos = resultado.data;
next();
};
}
Para los errores, define una clase propia que lleve el código HTTP y un mensaje apto para el usuario, y concentra la respuesta en un único middleware. De ese modo, las rutas lanzan errores y no se preocupan de cómo se presentan. Diferencia entre errores esperados, como una validación fallida, y errores inesperados, de los que no debes filtrar detalles internos al cliente.
// server/src/middleware/errores.js
import { log } from "../logger.js";
export class ErrorHttp extends Error {
constructor(estado, mensaje, detalle) {
super(mensaje);
this.estado = estado;
this.detalle = detalle;
}
}
export function manejarErrores(error, req, res, _next) {
const esperado = error instanceof ErrorHttp;
const estado = esperado ? error.estado : 500;
if (!esperado) log.error({ err: error, ruta: req.path }, "Error inesperado");
res.status(estado).json({
mensaje: esperado ? error.message : "Error interno del servidor",
detalle: esperado ? error.detalle : undefined
});
}
Logs y seguimiento de errores en producción
Cuando algo falla a las tres de la madrugada, los registros son tu única fuente de verdad. Pino produce registros estructurados en JSON a muy alta velocidad, lo que permite buscarlos y filtrarlos con facilidad en cualquier plataforma.
// server/src/logger.js
import pino from "pino";
export const log = pino({
level: process.env.NIVEL_LOG ?? "info",
redact: ["req.headers.cookie", "req.headers.authorization", "*.clave"]
});
La opción redact es esencial: evita que contraseñas, cookies o cabeceras de autorización terminen escritas en un archivo de registro. Nunca registres datos personales innecesarios. Complementa los logs con un servicio de seguimiento de errores, como Sentry, que agrupa fallos repetidos, adjunta la traza y te avisa cuando aparece uno nuevo. Configúralo para que ignore los errores esperados y no te llene la bandeja de ruido.
Añade también un identificador de petición que acompañe a cada línea de log. Con él puedes reconstruir lo que ocurrió en una petición concreta cuando un usuario te escribe diciendo que algo salió mal. Y expón un endpoint de salud, como el que vimos antes, para que tu plataforma pueda reiniciar el proceso si deja de responder.
Identificadores públicos que no revelan nada
Si expones identificadores numéricos consecutivos en las URL, cualquiera puede deducir cuántos registros tienes o intentar adivinar los de otros. Para los recursos que se comparten públicamente, como un enlace a un documento, conviene usar identificadores opacos. Hay tres enfoques habituales.
El primero es un UUID, preferiblemente en su versión 7, que es ordenable por tiempo y funciona bien como clave en índices. El segundo es una cadena aleatoria corta generada con una librería como nanoid, que se guarda en una columna adicional con restricción de unicidad. El tercero es codificar el número interno con una librería de ofuscación reversible, aunque esto solo oculta el número, no ofrece seguridad real.
ALTER TABLE documentos
ADD COLUMN enlace_publico text NOT NULL DEFAULT encode(gen_random_bytes(9), 'base64')
;
CREATE UNIQUE INDEX idx_documentos_enlace ON documentos (enlace_publico);
Recuerda que un identificador difícil de adivinar no sustituye a la comprobación de permisos. Un enlace público es, por definición, accesible para quien lo tenga, y en el resto de casos debes verificar siempre que el usuario pertenece al inquilino correcto.
Correo transaccional
Un SaaS necesita enviar correos de forma fiable: confirmación de cuenta, restablecimiento de contraseña, avisos y recibos. No envíes correo desde tu propio servidor: la reputación de las direcciones IP y la configuración de autenticación del dominio son un campo minado. Usa un proveedor especializado como Mailgun, Postmark o similar.
Configura en tu dominio los registros SPF, DKIM y DMARC, que demuestran a los receptores que tus mensajes son legítimos. Sin ellos, tus correos terminarán en la carpeta de spam. Usa un subdominio dedicado para el envío transaccional, de modo que la reputación del correo corporativo quede aislada.
Para las plantillas, un lenguaje como MJML te permite escribir correos responsivos sin pelearte con las tablas anidadas y los problemas de cada cliente de correo. Mantén un diseño sencillo, siempre con una versión en texto plano. Si quieres ver el envío desde Node con más detalle, puedes revisar cómo enviar correos electrónicos desde tu servidor Node.js con Nodemailer.
Por último, nunca envíes un correo dentro del ciclo de la petición HTTP si puedes evitarlo. Si el proveedor tarda, tu usuario espera. Encola el envío, por ejemplo en Redis, y procésalo en segundo plano con reintentos.
Preparar la infraestructura y el despliegue
La elección de dónde alojar el producto condiciona los costes y la libertad futura. Las opciones se mueven entre dos polos: plataformas gestionadas que lo hacen casi todo por ti a un precio mayor por unidad de recursos, y máquinas virtuales o nubes públicas donde tú gestionas más piezas a cambio de más control y un coste menor a escala.
Para empezar, una plataforma de contenedores o de aplicaciones gestionadas, con base de datos PostgreSQL y Redis administrados, elimina el trabajo de copias de seguridad, parches y alta disponibilidad. Es dinero bien gastado: tu tiempo vale más que la diferencia de precio. Al elegir, comprueba que podrías exportar tus datos y mover los contenedores a otro proveedor sin reescribir nada.
Empaquetar el servidor en un contenedor te da exactamente esa portabilidad. Un Dockerfile de varias etapas mantiene la imagen final pequeña y sin herramientas de compilación.
FROM node:24-slim AS deps
WORKDIR /app
COPY server/package*.json ./
RUN npm ci --omit=dev
FROM node:24-slim
WORKDIR /app
ENV NODE_ENV=production
COPY --from=deps /app/node_modules ./node_modules
COPY server/src ./src
USER node
EXPOSE 4000
CMD ["node", "src/index.js"]
Si es la primera vez que trabajas con contenedores, el artículo Docker paso a paso: construye, ejecuta y despliega tu primera app te explica el flujo completo. El cliente, al ser archivos estáticos, se publica en un servicio de alojamiento estático con CDN. Una vez desplegado, la autenticación por cookie entre dos dominios exige cuidado: lo más sencillo es servir cliente y API bajo el mismo dominio, con la API en una ruta o un subdominio, para que las cookies sean de primera parte.
Comprueba también la política de seguridad de contenido. Una cabecera Content-Security-Policy restrictiva limita desde dónde puede cargar scripts, estilos e imágenes tu aplicación, y reduce el impacto de un ataque de inyección de scripts. Empieza en modo informe, revisa lo que bloquearía y endurece poco a poco.
CORS: cuándo lo necesitas y cómo configurarlo
CORS es el mecanismo por el que el navegador decide si una página de un origen puede leer respuestas de otro. Si sirves cliente y API desde el mismo origen, no necesitas nada. Si están en dominios distintos, el servidor debe indicar de forma explícita qué origen permite, y debes habilitar el envío de credenciales cuando uses cookies.
Hay plataformas que no permiten configurar estas cabeceras en la capa de infraestructura, de modo que lo más práctico es resolverlo en la propia aplicación con el paquete cors, como hicimos al principio. Evita el comodín * en cualquier API que use credenciales, porque los navegadores lo rechazan, y trabaja con una lista de orígenes permitidos leída desde una variable de entorno.
const permitidos = (process.env.ORIGENES_PERMITIDOS ?? "").split(",");
app.use(
cors({
origin(origen, devolver) {
if (!origen || permitidos.includes(origen)) return devolver(null, true);
devolver(new Error("Origen no permitido"));
},
credentials: true
})
);
Las peticiones con métodos distintos de GET o con cabeceras personalizadas desencadenan una petición previa de comprobación. Si ves errores misteriosos en la consola del navegador, revisa primero esa petición previa y las cabeceras de la respuesta antes de culpar al código de la ruta.
Edición de texto enriquecido y otras piezas opcionales
Muchos productos necesitan que los usuarios escriban texto con formato. Construir un editor desde cero es un pozo sin fondo, así que elige una librería madura. ProseMirror ofrece un modelo de documento estricto y muy extensible, ideal si necesitas control total, mientras que otras opciones más cerradas se integran más rápido pero ofrecen menos libertad. Guarda el documento en un formato estructurado, como JSON, y no como HTML, para poder migrarlo o renderizarlo de otras formas en el futuro. Si aceptas HTML de los usuarios, sanitízalo siempre en el servidor.
Otras piezas que se añaden más adelante son los pagos recurrentes con un procesador como Stripe, que gestiona tarjetas y facturas, los términos de servicio y la política de privacidad, redactados con asesoramiento legal, y una página de aterrizaje clara con un único llamado a la acción. Deja que el producto madure antes de invertir en cada una de ellas.
Errores comunes al construir un SaaS
La lista de equivocaciones repetidas es larga, pero unas pocas aparecen una y otra vez. La primera es sobredimensionar la arquitectura: microservicios, colas, clústeres y múltiples bases de datos para un producto sin usuarios. Un monolito bien organizado resiste muchísimo más tráfico del que imaginas. Si más adelante necesitas dividirlo, entenderás mejor los límites naturales, algo que se explica bien en el artículo sobre diseño de sistemas: de un servidor a una arquitectura escalable.
La segunda es dejar la seguridad para el final. Las contraseñas sin derivar, las consultas sin parametrizar y los secretos en el repositorio son decisiones muy difíciles de corregir una vez hay datos reales. La tercera es no tener copias de seguridad probadas: una copia que nunca has restaurado es solo una esperanza. Programa restauraciones periódicas en un entorno de pruebas.
La cuarta es ignorar la observabilidad hasta el primer incidente. Con logs estructurados, un seguimiento de errores y una comprobación de salud externa, detectarás los problemas antes que tus clientes. La quinta es medir poco: sin métricas básicas, como registros nuevos, usuarios activos y tiempos de respuesta, decides a ciegas.
Buenas prácticas de operación y costes
Automatiza el despliegue con una canalización de integración continua que ejecute las pruebas, compile el cliente, construya la imagen y la publique. Cada paso manual es una oportunidad para el error. Mantén los entornos de desarrollo, pruebas y producción lo más parecidos posible, y gestiona los secretos mediante el almacén de secretos de tu plataforma, no con archivos en el repositorio.
Revisa los costes con regularidad. Establece alertas de gasto en tu proveedor y entiende qué recursos dominan la factura. Con frecuencia, una base de datos sobredimensionada o un tráfico de salida inesperado explican la mayor parte. Aplica el principio de pagar en proporción al uso: empieza con instancias pequeñas y escala cuando los datos lo justifiquen.
Planifica el apagado ordenado del servidor. Al recibir la señal de terminación, deja de aceptar nuevas peticiones, espera a que terminen las que están en curso y cierra el pool de base de datos y la conexión a Redis. Así los despliegues no cortan las operaciones de tus usuarios a medias.
const servidor = app.listen(puerto);
process.on("SIGTERM", () => {
log.info("Cerrando servidor");
servidor.close(async () => {
await pool.end();
await redis.quit();
process.exit(0);
});
});
Cuida, por último, tu propio bienestar. Un producto en solitario puede devorar tus noches y fines de semana. Define horarios, automatiza lo repetitivo y acepta que habrá incidencias imperfectas. Un proyecto sostenible es aquel que puedes mantener durante años sin quemarte.
Conclusiones
Construir tu primer SaaS no exige tecnologías exóticas, sino decisiones coherentes y bien entendidas. Un cliente de una sola página con Vite y Preact, un servidor Express 5 con una estructura plana, PostgreSQL con SQL escrito a mano y seguridad a nivel de fila, y Redis para sesiones y caché forman una base sólida, barata de operar y fácil de trasladar entre proveedores.
Las decisiones que más rentabilidad dan son las menos vistosas: validar toda entrada, centralizar los errores, registrar con cuidado sin filtrar datos sensibles, aislar a los inquilinos desde la base de datos y probar las copias de seguridad. Cada una te ahorra un problema grave en el futuro.
Empieza por un alcance pequeño, publica pronto y escucha a tus primeros usuarios. La arquitectura puede evolucionar con el producto, pero la confianza que depositan los clientes en tus datos es mucho más difícil de recuperar si se pierde. Con esta base ya tienes lo necesario para pasar de una idea a un servicio real que cobra, escala y se puede mantener.
