Para una aplicación pequeña, añadir una base de datos suele significar levantar PostgreSQL o MySQL, configurar usuarios, guardar credenciales y mantener otro servicio. A veces todo eso está justificado. Otras veces sólo necesitamos guardar datos de forma fiable en el mismo ordenador que ejecuta el programa.
Ahí encaja SQLite. No es una base de datos de juguete por estar guardada en un archivo. Pero tampoco basta con decir que soporta muchas visitas para concluir que sirve para cualquier arquitectura. La decisión depende sobre todo de dónde viven los datos, cómo escribimos y cuántos procesos necesitan coordinarse.

Qué cambia frente a PostgreSQL o MySQL
SQLite funciona como una biblioteca dentro de la aplicación. No tenemos un servidor SQL independiente al que conectarnos por red. El programa abre un archivo y utiliza el motor para consultar y modificar los datos.
Esto reduce piezas que administrar, aunque no elimina el mantenimiento. Seguimos necesitando copias, migraciones de esquema, espacio libre, permisos y una estrategia de recuperación. El archivo tampoco está cifrado automáticamente porque lo gestione SQLite.
En una aplicación de escritorio, una herramienta de línea de comandos o un servicio pequeño alojado en una sola máquina, ese modelo puede simplificar bastante el despliegue. Si varios servidores necesitan modificar los mismos datos, una base de datos cliente-servidor suele ofrecer una separación más adecuada. La guía de usos de SQLite parte precisamente de esa diferencia.
Un ejemplo pequeño que podemos ejecutar
Vamos a guardar trabajos pendientes, como podría hacer una herramienta que organiza tareas locales. No necesitamos instalar un servicio. Python incluye el módulo sqlite3, aunque la versión del motor depende de cómo esté construido Python.
Consultamos esa versión con:
python3 -c 'import sqlite3; print(sqlite3.sqlite_version)'
Preparamos una carpeta vacía de pruebas y guardamos lo siguiente como tareas.py. El nombre ejemplo-tareas.db corresponde sólo a este ejemplo, no a una base existente:
import sqlite3
db = sqlite3.connect('ejemplo-tareas.db', timeout=5)
try:
db.execute('PRAGMA foreign_keys = ON')
with db:
db.execute('''
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY,
titulo TEXT NOT NULL,
terminada INTEGER NOT NULL DEFAULT 0
CHECK (terminada IN (0, 1))
)
''')
db.execute(
'INSERT INTO tareas (titulo) VALUES (?)',
('Preparar la copia de seguridad',),
)
for fila in db.execute(
'SELECT id, titulo, terminada FROM tareas ORDER BY id'
):
print(fila)
finally:
db.close()
Lo ejecutamos desde esa carpeta:
python3 tareas.py
En la primera ejecución veremos una tarea pendiente. Cada ejecución añade otra fila, algo útil para distinguir una base persistente de una lista que se pierde al cerrar el programa. Las consultas usan parámetros para los valores, sin concatenar el contenido del usuario dentro del SQL.
El bloque with db confirma la transacción si termina correctamente y la revierte si hay una excepción. El cierre explícito libera la conexión. Son operaciones distintas, tal como documenta el módulo sqlite3 de Python.
El límite que importa es la escritura concurrente
Imaginemos que dos procesos quieren marcar una tarea como terminada. SQLite coordina el acceso, pero sólo permite una transacción de escritura a la vez sobre esa base. Si la primera mantiene el bloqueo demasiado tiempo, la segunda tendrá que esperar o recibir un error.
Podemos observarlo con dos conexiones al archivo del ejemplo. Guardamos este segundo programa como bloqueo.py:
import sqlite3
primera = sqlite3.connect('ejemplo-tareas.db', timeout=0.1)
segunda = sqlite3.connect('ejemplo-tareas.db', timeout=0.1)
try:
primera.execute('BEGIN IMMEDIATE')
primera.execute('UPDATE tareas SET terminada = 1 WHERE id = 1')
try:
segunda.execute('UPDATE tareas SET terminada = 1 WHERE id = 1')
except sqlite3.OperationalError as error:
print('Segunda conexión:', error)
segunda.rollback()
primera.commit()
with segunda:
segunda.execute('UPDATE tareas SET terminada = 1 WHERE id = 1')
print('Actualización terminada después de liberar el bloqueo')
finally:
primera.close()
segunda.close()
La segunda conexión espera hasta su límite y puede mostrar database is locked. Después de confirmar la primera, la misma escritura ya puede continuar. Este ejemplo provoca una espera concreta, no mide el rendimiento de una aplicación real.
La documentación de transacciones explica cuándo se obtiene el bloqueo de escritura. BEGIN IMMEDIATE permite solicitarlo al empezar, en lugar de descubrir más tarde que no podemos convertir una lectura en escritura. No lo añadimos a todas las consultas por costumbre.
Mantener cortas las transacciones
Un caso fácil de empeorar es abrir una transacción, modificar una fila, llamar a una API que tarda varios segundos y confirmar al volver. Durante ese tiempo estamos reteniendo un recurso que otros escritores necesitan.
Podemos preparar lo que no requiere la transacción antes de abrirla y dejar dentro únicamente las comprobaciones y cambios que deban ser atómicos. Eso exige diseñar qué pasa si los datos cambian entretanto. Sacar código fuera sin revisar esas condiciones tampoco es una solución general.
El tiempo de espera, como timeout=5 en la conexión de Python, ayuda a absorber contenciones breves. No añade escritores simultáneos ni arregla una operación que mantiene el bloqueo durante minutos. Si hacemos reintentos, deben tener un límite y respetar la transacción completa, sobre todo cuando hay efectos externos que podrían repetirse.
Qué aporta WAL y qué no soluciona
El modo WAL permite que lectores y un escritor progresen con menos interferencias en muchos casos. Sigue habiendo un único escritor a la vez. No convierte un archivo compartido entre servidores en un servicio SQL distribuido.
Antes de activarlo en producción comprobamos que el motor esté mantenido. La documentación de WAL recoge una corrección de concurrencia de marzo de 2026, incluida desde 3.51.3 y en algunas ramas anteriores. Si dependemos de una biblioteca del sistema con parches retroportados, consultamos su mantenimiento, no sólo el número base.
En una base de pruebas y con una versión corregida podemos activarlo así, desde la conexión:
modo = db.execute('PRAGMA journal_mode = WAL').fetchone()[0]
print(modo)
Comprobamos que devuelve wal. No lo pegamos después de db.close() en el ejemplo anterior, sino mientras la conexión está abierta. La elección queda asociada a esa base y puede afectar a las demás conexiones que la utilicen.
Aparecen archivos auxiliares como -wal y -shm. El WAL puede contener cambios confirmados que todavía no han pasado al archivo principal. No borramos esos archivos para «limpiar», ni copiamos únicamente el .db mientras la aplicación sigue escribiendo. WAL requiere además que los procesos compartan el mismo equipo, no un sistema de archivos de red entre máquinas distintas.
Hacer una copia que podamos restaurar
Para una base activa podemos usar la API de copias de SQLite. En Python está expuesta mediante backup. Este ejemplo crea copia-tareas.db en la carpeta de pruebas y sustituye su contenido si ya existía:
import sqlite3
origen = sqlite3.connect('ejemplo-tareas.db')
destino = sqlite3.connect('copia-tareas.db')
try:
origen.backup(destino)
print(destino.execute('PRAGMA integrity_check').fetchone()[0])
print(destino.execute('SELECT COUNT(*) FROM tareas').fetchone()[0])
finally:
destino.close()
origen.close()
Esperamos ok en la comprobación de integridad y revisamos que estén los datos previstos. En una aplicación real abrimos una copia en un entorno separado y probamos las operaciones que necesitamos recuperar. Que el archivo exista no demuestra que el programa pueda volver a trabajar con él.
También necesitamos varias versiones de las copias y almacenamiento separado del disco original. Automatizar siempre sobre el mismo destino puede sobrescribir una copia buena después de un borrado accidental. Y copiar una base con datos personales mantiene esos datos en la copia, aunque no haya usuarios SQL o contraseñas de conexión.
Cuándo elegiría una base de datos cliente-servidor
Si necesitamos varias réplicas de la aplicación escribiendo desde máquinas distintas, permisos SQL separados entre servicios o una infraestructura de alta disponibilidad, empezaría por valorar PostgreSQL o MySQL. Intentar obtenerlo montando el mismo archivo SQLite por red complica justo la parte que parecía sencilla.
Para un servicio pequeño en un único servidor, miraría antes la duración y frecuencia de las escrituras, los tiempos de espera y el plan de recuperación. Un contador de visitas no describe todo eso. Una página con muchas lecturas cacheadas y una herramienta con pocas peticiones que escriben sin parar pueden tener necesidades muy distintas.
También revisaría las consultas antes de culpar al motor. Un índice ausente o una lectura innecesaria puede perjudicar cualquiera de las opciones. Tenemos una explicación de ese trabajo con EXPLAIN e índices en MySQL, aunque los planes y detalles de cada motor sean diferentes.
SQLite permite empezar con menos servicios cuando el acceso a los datos encaja con su modelo. Mantener esa sencillez exige cuidar las transacciones y las copias desde el principio. Si después necesitamos varios servidores escribiendo de forma independiente, tendremos un motivo concreto para cambiar, en lugar de hacerlo por miedo a que un archivo parezca demasiado pequeño para producción.
