Volver

Convex: El Backend que TypeScript Merece

Por qué dejé de configurar bases de datos y empecé a construir producto

4 min

“No quiero configurar una base de datos. Quiero construir mi producto.”

Ese fue mi momento de claridad después de 20+ años configurando backends.

El Problema

Cada proyecto nuevo significa:

  • Elegir ORM (Prisma? Drizzle? TypeORM?)
  • Configurar migraciones
  • Setup de Redis para caché
  • WebSockets para tiempo real
  • Escribir el “pegamento” entre todo

En Viago Travel perdí 2 semanas solo en infraestructura antes de escribir una sola línea de lógica de negocio.

Eso no escala para un indie hacker.

Mi Descubrimiento con Convex

Theo (t3.gg) migró T3 Chat a Convex. Lo ignoré por meses—sonaba a “Firebase con esteroides” y vendor lock-in.

Estaba equivocado.

Lo que entendí después de probarlo: Convex es React para el backend.

No “abstrae” tu base de datos. Te da mejores primitivas para construir:

// convex/tasks.ts
import { query, mutation } from "./_generated/server";
import { v } from "convex/values";

// Query reactiva - la UI se actualiza automáticamente
export const list = query({
  args: {},
  handler: async (ctx) => {
    return await ctx.db.query("tasks").collect();
  },
});

// Mutation con tipos automáticos
export const create = mutation({
  args: { text: v.string() },
  handler: async (ctx, args) => {
    await ctx.db.insert("tasks", {
      text: args.text,
      completed: false
    });
  },
});

En el frontend:

// React component
import { useQuery, useMutation } from "convex/react";
import { api } from "../convex/_generated/api";

export function Tasks() {
  const tasks = useQuery(api.tasks.list);
  const createTask = useMutation(api.tasks.create);

  // tasks se actualiza AUTOMÁTICAMENTE cuando cambia la DB
  // Sin polling. Sin WebSockets manuales. Sin configuración.
}

Type-safety de extremo a extremo. Sin duplicar tipos. Sin generar schemas.

Lo que Cambió

Antes (stack típico)

  • Setup inicial: 2-3 días
  • Tiempo real: Configurar Redis + WebSockets
  • Caché: Implementar manualmente
  • Migraciones: Gestionar con scripts

Después (Convex)

  • Setup inicial: 30 minutos
  • Tiempo real: Por defecto
  • Caché: Automático (98% hit rate según Theo)
  • Schema: TypeScript puro

¿Vendor Lock-in?

Mi mayor objeción. Pero hay dos tipos de lock-in:

  1. Código propietario → Malo
  2. Servicios gestionados → Estás pagando por no escribir código que podrías hacer tú mismo

Convex es mayormente #2. ¿Quieres configurar tu propio sistema de invalidación de caché con Redis? Puedes. ¿Vale tu tiempo? Probablemente no.

Y si realmente necesitas salir: Convex es open source. Self-host cuando quieras.

Para Quién Es (y para quién no)

Úsalo si:

  • Tu stack es 100% TypeScript (frontend + backend)
  • Eres indie hacker/solopreneur que valora velocidad
  • Construyes productos que necesitan tiempo real
  • Odias configurar infraestructura

No lo uses si:

  • Tu equipo de Data Science necesita SQL directo para analytics
  • Tu backend está en Go, Rust, Python
  • Necesitas control absoluto sobre cada query

Mi Stack Actual

Para proyectos nuevos:

Frontend:    Next.js + TypeScript
Backend:     Convex
Auth:        Kinde
Pagos:       Stripe
Deploy:      Railway

Tiempo de setup a producción: ~2 horas.

No es perfecto. Pero me deja tiempo para lo que importa: construir el producto, no la infraestructura.

Conclusión

Convex no es para todos. Pero si eres desarrollador TypeScript construyendo productos—especialmente como indie hacker—merece tu atención.

La pregunta no es “¿puedo construir esto con Postgres + Prisma + Redis?”

Es: “¿quiero pasar mis fines de semana configurando infraestructura o construyendo features?”

Yo elegí features.

¿Probando algo similar? Cuéntame: jlopezlira@gmail.com

Si esto te ahorró tiempo de investigación, compártelo. Alguien más está evaluando su stack en este momento.