---
title: "PocketBase: un backend completo en un solo archivo"
description: "Descubrí PocketBase, el backend as a service open source escrito en Go que combina SQLite, autenticación, API REST y tiempo real en un solo binario. Ideal para MVPs y proyectos pequeños y medianos."
url: "https://www.devlights.com/es/blog/pocketbase-backend-open-source"
language: es
published: 2026-10-25T13:00:00.000Z
updated: 2026-10-28T22:29:57.316Z
type: devtalk
authors: ["Jesús Zini"]
category: "DevTalks"
tags: ["PocketBase", "Backend", "Open source", "SQLite", "Go", "BaaS", "MVP", "Desarrollo web", "REST API"]
---

# PocketBase: un backend completo en un solo archivo

> PocketBase es un backend open source escrito en Go que te da base de datos, autenticación, API REST, tiempo real y panel de administración en un único binario. Ideal para prototipos, MVPs y aplicaciones pequeñas o medianas.

[YouTube](https://www.youtube.com/watch?v=2mC4zqdTWs4)

> **TL;DR**
>
> PocketBase es un backend open source escrito en Go que te da base de datos, autenticación, API REST, sincronización en tiempo real y panel de administración, todo en un único binario. Ideal para prototipos, MVPs y aplicaciones pequeñas o medianas donde no necesitás una arquitectura distribuida.

## ¿Qué es PocketBase?

En el ecosistema de herramientas para desarrollo backend, pocas propuestas son tan directas como PocketBase: descargás un archivo, lo ejecutás y tenés un backend funcionando.

PocketBase es un **backend as a service de código abierto** escrito en Go que usa SQLite como motor de base de datos. La combinación puede sonar modesta, pero en la práctica entrega algo que muchos proyectos necesitan y pocas herramientas ofrecen: **velocidad de setup sin sacrificar funcionalidad**.

Y hay algo más que lo distingue: podés usarlo como framework. Eso significa que podés escribir tu propia lógica de negocio en Go o JavaScript y seguir teniendo un backend portable al final. No estás encerrado en una caja negra.

## ¿Qué incluye out of the box?

La lista de funcionalidades que PocketBase trae sin configuración adicional es llamativamente larga para algo tan liviano:

**Base de datos y API** SQLite como motor de persistencia, con endpoints REST generados automáticamente para cada colección. Cada endpoint incluye validación, paginación y filtros, lo que elimina buena parte del boilerplate típico de un backend.

**Autenticación completa** JWT, OAuth2, MFA y OTP están disponibles desde el inicio. También maneja roles diferenciados entre administradores y usuarios de la aplicación, sin necesidad de configurar nada por separado.

**Sincronización en tiempo real** Actualizaciones vía WebSocket disponibles sobre las colecciones. Cualquier cambio en los datos se puede propagar al cliente sin polling.

**Panel de administración web** Interfaz para gestionar colecciones, usuarios, permisos y configuraciones. Útil especialmente en etapas tempranas de un proyecto donde querés iterar rápido.

**Gestión de archivos** Subida y manejo de archivos integrado, sin necesidad de configurar un servicio externo para casos de uso básicos.

**Migraciones y vistas SQL** Soporte para migraciones de esquema y vistas SQL, lo que le da más poder al modelo de datos sin salir del ecosistema.

**Extensibilidad** Para lógica más avanzada, PocketBase expone hooks y permite escribir transacciones atómicas, triggers y stored procedures en Go o JavaScript.

## Ventajas concretas

**Despliegue sin fricción** Un solo binario. No hay dependencias externas, no hay configuración de entorno compleja, no hay Docker obligatorio. Bajás el ejecutable y levantás el servidor. Para desarrollo local o despliegues en VPS, esto reduce el tiempo de setup a minutos.

**Código abierto y personalizable** Al ser open source, podés modificarlo, auditarlo e integrarlo en pipelines propios. No dependés de un proveedor que puede cambiar precios o deprecar funciones.

**APIs listas para usar** El tiempo que normalmente va a construir endpoints CRUD con validación y paginación se puede invertir en la lógica del producto. PocketBase resuelve ese trabajo repetitivo automáticamente.

**Tipado de cliente con herramientas de la comunidad** La comunidad desarrolló `pocketbase-typegen`, una herramienta que genera tipos TypeScript a partir del esquema de tus colecciones. Una adición muy útil para proyectos frontend.

## Un ejemplo práctico con el SDK de JavaScript

La forma más rápida de entender el valor de PocketBase es ver cuánto código necesitás para interactuar con una colección desde el frontend:

```
import PocketBase from 'pocketbase';

const pb = new PocketBase('http://127.0.0.1:8090');

// Autenticación de usuario
const authData = await pb.collection('users').authWithPassword(
    'user@example.com',
    'mi-password-segura'
);

// Listar registros con filtro y paginación
const posts = await pb.collection('posts').getList(1, 20, {
    filter: 'published = true',
    sort: '-created',
    expand: 'author'
});

// Crear un nuevo registro
const newPost = await pb.collection('posts').create({
    title: 'Mi primer post',
    content: 'Contenido del artículo...',
    published: false
});

// Suscribirse a cambios en tiempo real
pb.collection('posts').subscribe('*', (event) => {
    console.log(`Evento: ${event.action}`, event.record);
});
```

Con esto tenés autenticación, listado con filtros, creación y tiempo real. Sin escribir una línea de backend.

## Limitaciones a considerar

PocketBase no es la solución para todo. Antes de adoptarlo, es importante tener claras sus restricciones:

**Escalabilidad horizontal** SQLite no está diseñado para bases de datos distribuidas ni para soportar carga de escritura muy alta en múltiples nodos simultáneos. Para aplicaciones que anticipan tráfico masivo o necesitan replicación, otras opciones son más adecuadas.

**Lógica backend compleja** PocketBase resuelve bien los casos CRUD y los flujos de autenticación estándar. Si tu aplicación requiere lógica de negocio muy compleja o integraciones profundas con sistemas externos, probablemente necesites complementarlo con servicios adicionales.

**Ecosistema relativamente joven** Es un proyecto nuevo y la comunidad, aunque activa, no tiene la madurez de alternativas como Firebase o Supabase. Hay menos librerías, menos recursos y menos ejemplos disponibles.

**Transacciones atómicas personalizadas** Para casos que requieren transacciones complejas más allá de los hooks disponibles, la extensibilidad tiene sus límites dentro del modelo que ofrece.

## ¿Cuándo tiene sentido usarlo?

PocketBase encaja bien en contextos específicos:

**Prototipos y MVPs** donde la velocidad de desarrollo es la prioridad y la escala inicial es limitada. Podés tener un backend funcional en horas en lugar de días.

**Aplicaciones pequeñas y medianas** que no necesitan arquitectura distribuida y cuyo volumen de datos y tráfico es manejable con SQLite.

**Proyectos personales o de freelancers** donde los costos de plataformas BaaS comerciales no están justificados y se prefiere una solución self-hosted.

**Herramientas internas** dentro de organizaciones donde el control total sobre los datos y la ausencia de costos recurrentes son requisitos.

## PocketBase vs. las alternativas

Para elegir bien, vale la pena ubicar PocketBase en el contexto de sus competidores directos:

|  | PocketBase | Firebase | Supabase | Strapi |
| --- | --- | --- | --- | --- |
| **Hosting** | Self-hosted | Google Cloud | Self-hosted / Cloud | Self-hosted / Cloud |
| **Base de datos** | SQLite | NoSQL (Firestore) | PostgreSQL | Cualquiera |
| **Open source** | ✅ | ❌ | ✅ | ✅ |
| **Escalabilidad** | Limitada | Alta | Alta | Media |
| **Setup** | Muy simple | Simple | Moderado | Moderado |
| **Ideal para** | MVPs, pequeños proyectos | Apps de escala | Apps complejas | CMS headless |

**Firebase** es la opción cuando necesitás escala garantizada, pero implica dependencia de la infraestructura de Google y costos crecientes.

**Supabase** es más robusto para aplicaciones complejas al usar PostgreSQL, y también es open source, pero el setup inicial es más pesado.

**Strapi** tiene sentido cuando el caso de uso es un headless CMS con flujos de contenido, no tanto como backend de aplicación general.

## Conclusión

PocketBase resuelve un problema real: la brecha entre "necesito un backend" y "tengo un backend funcionando" es demasiado grande en muchos stacks modernos.

Para equipos que trabajan en MVPs, herramientas internas o proyectos donde la velocidad de iteración importa más que la escala futura, PocketBase ofrece una propuesta difícil de ignorar. Un solo binario, sin dependencias, con autenticación completa, API REST automática y tiempo real.

Sus limitaciones son reales, pero también son predecibles. Si tu aplicación crece más allá de lo que SQLite puede manejar, vas a tener el problema (bueno) de haber validado tu producto. Migrar entonces es una decisión con contexto, no una apuesta en el vacío.

En Devlights evaluamos herramientas como PocketBase en el contexto de cada proyecto, buscando el balance correcto entre velocidad de entrega y solidez técnica. Si estás pensando en la arquitectura de tu próxima aplicación y querés una segunda opinión, [hablemos](https://www.devlights.com/es/contact).