Preguntó mi madre.

Pasamos mucho tiempo en Torrevieja, y los empadronados viajan gratis en los autobuses urbanos. Por aquel entonces casi siempre llegábamos en avión, sin coche de alquiler ni coche propio, así que nos movíamos en autobús. Todos los extranjeros que conocíamos, y muchos vecinos de aquí, tenían la misma pregunta sobre él: ¿cuándo?

Los autobuses en sí parecían ir puntuales. Puede que incluso lo fueran. El problema era el horario. Solo indica las salidas desde las cabeceras, y en cualquier parada intermedia te toca calcularlo a ojo.

Así que hicimos una app que hace el cálculo por ti. Se llama Cuando, que en español es exactamente eso: toda la descripción del puesto en una palabra. En su icono hay un autobús, y su puerta es un signo de interrogación.

Desde esta semana, Cuando está en Google Play y en la App Store, con una versión web para todos los demás. Es gratis, habla siete idiomas y conoce las líneas de autobús de la ciudad parada a parada.

Qué hace

  • El mapa muestra todas las líneas y todas las paradas. Activa todas las líneas o deja solo la que necesitas.
  • La parada más cercana, las recientes, los favoritos, y un buscador que conoce tanto paradas como lugares.
  • Una parada muestra las líneas que pasan por ella y cuándo llegan los próximos autobuses de cada una. Debajo hay una línea en letra pequeña: «El horario es aproximado». Es la frase más honesta de la app, y más abajo explico por qué.
  • Una línea muestra todo su recorrido, parada a parada.
  • Informes. «Hora de salida incorrecta» y compañía, con una foto o un vídeo si los tienes. Llegan a nuestro editor, justo al lado de los datos a los que se refieren.
  • Siete idiomas: inglés, español, ruso, alemán, polaco, bielorruso y chino. Torrevieja es ese tipo de sitio.
  • Inicio de sesión con email, Apple o Google.

No había datos, así que los dibujamos

No había nada que importar. Ni feed oficial, ni un archivo de horarios que un buscador pudiera encontrar, ni API: solo los autobuses y esas horas de salida en los extremos de cada línea. Así que las dos primeras cosas que construimos no fueron la app.

La primera fue un cronómetro para el móvil. Es una web app diminuta con dos botones: pulsas Start en una parada y Stop en la siguiente, y guarda el recorrido GPS entre ambas y los segundos que ha tardado, como una arista sugerida.

El trabajo de campo lo hicieron mi padre y mi hermana pequeña: unos cuatro días, de tres a cuatro horas al día, contando los trayectos hasta donde empieza cada línea.

La segunda fue un editor: una pequeña app en Vue sobre un mapa. Convierte esas sugerencias en paradas y en las aristas entre ellas. Una arista es una polilínea que puedes arrastrar a su sitio, más un tiempo de trayecto.

Luego mi hermano repasó cada línea a mano, doblando las polilíneas para que siguieran las calles reales, con sus curvas y rotondas. Probamos a ajustarlas automáticamente a las calles del servicio de mapas, y no sirvió. El tiempo de trayecto de cada arista se elige en minutos y segundos, y por eso cada duración en nuestros datos tiene esta pinta:

stations:
  - uid: c-mayor
    name: C/ Mayor
    address: "Calle Mayor, 59"
    departure_for: [lines/a-torrevieja, lines/a-2-torrevieja]
lines:
  - uid: a-torrevieja
    name: A
    route: La Mata - Torrevieja
    color: '#FF8B37'
    opposite: lines/a-la-mata
    stations: [stations/c-mayor, stations/petanca, …]
route_edges:
  - from: stations/c-mayor
    to: stations/petanca
    line: lines/a-torrevieja
    duration: 01m40s
    polygon: [{ latitude: …, longitude: … }, …]

Mientras editamos, todo vive en la base de datos, y luego se exporta de vuelta a YAML en git, así que la red tiene historial y diff como cualquier otro código.

Hoy son 163 paradas, 16 líneas (A, A.2, B, C, DF, E, G, cada una en ambos sentidos, más la del aeropuerto) y 239 aristas. El tramo típico entre dos paradas dura alrededor de un minuto y medio.

Los horarios llegaron al final, de donde pudimos sacarlos: vecinos que nos mandan actualizaciones (nuestros «agentes»), medios escritos para turistas y horarios que la gente publica en internet. También entraron a mano. A mediados de noviembre solo las líneas A, A.2, C y G tenían salidas; B, DF y E no tenían ninguna. Luego, en las dos primeras semanas de diciembre, una segunda persona se unió al backend y metió el resto: 36 commits, un archivo de horarios que creció hasta 280 entradas y una «С» cirílica colada en el nombre de una parada por la distribución del teclado. (Uno de sus commits se titula ашч, que es «fix» tecleado con un teclado ruso. Respeto.)

Una entrada del horario es un patrón, no una lista:

- from: stations/c-mayor
  line: lines/a-torrevieja
  time: "07:30"
  recurrence: 30m
  till: "20:01"
  days: [mon, tue, wed, thu, fri]

Un generador la expande en salidas concretas para cada día.

Todo el truco

Así es como Cuando sabe cuándo llegará un autobús a tu parada, tal cual del README que escribí la primera noche:

Ir de Calle Morera a Calle Mayor 59 llevará 9 minutos (3+2+2+2). Por la base de datos principal sabemos que el autobús sale a las 7:30 de Calle Mayor. La hora de llegada a Calle Morera será las 7:39.

¿Recuerdas el horario que solo indica las salidas desde los extremos de cada línea? Es todo lo que necesitamos de él. Todo lo demás es esa hora de salida más la suma de las aristas que hay en medio. Por eso la app dice «aproximado»: nuestra aritmética es exacta, pero el autobús está atascado detrás de una furgoneta de reparto en la Calle Mayor.

Ocho semanas de ArangoDB

Una red de autobuses es un grafo, así que el primer día acabó en una base de datos de grafos. ArangoDB, con las líneas como grafo y la pregunta como un recorrido:

FOR node, edge, path IN 0..100 INBOUND start
  GRAPH "routes" OPTIONS { uniqueVertices: "path" }
  FILTER path.vertices[-1].is_departure == true
  SORT LENGTH(path.edges) ASC LIMIT 1

Funcionaba. También era una segunda base de datos, corriendo al lado de la que guardaba todo lo demás. En septiembre la capa de datos se pasó a PocketBase, y el recorrido se convirtió en un bucle en Go que pedía un tramo cada vez. El 11 de octubre se convirtió en mi hack favorito de todo el proyecto. Aquí está, un poco recortado:

WITH RECURSIVE dfs(station_id, departure, path, line, depth) AS (
  SELECT route_edges.`from`, stations.id, "00m00s", line, 0
  FROM route_edges JOIN stations ON route_edges.`from` = stations.id
  WHERE is_departure = TRUE AND line = {:line}
  UNION ALL
  SELECT route_edges.`to`, dfs.departure,
         dfs.path || ',' || route_edges.duration, route_edges.line, dfs.depth + 1
  FROM dfs JOIN route_edges ON route_edges.`from` = dfs.station_id
  WHERE route_edges.line = dfs.line OR dfs.line IS NULL
)
SELECT * FROM dfs WHERE station_id = {:station_to} ORDER BY depth;

Una CTE recursiva en SQLite a secas recorre la línea desde su primera parada y va recogiendo las duraciones por el camino. No parece gran cosa, y me costó unos cuantos días dejarla bien. El commit que borró ArangoDB, 618 líneas, llegó doce segundos después del que la sustituía. Nunca iba a ser una votación reñida.

La semana pasada, las horas de llegada dejaron de recorrer el grafo del todo. Ahora una pequeña tarea precalcula, para cada línea, los segundos de cada parada a la siguiente como un único vector. Una hora de llegada pasa a ser «salida más la suma de un trozo de ese vector», y eso lo responde cualquier base de datos en un abrir y cerrar de ojos.

Un binario, un Worker, una app

El stack es pequeño a propósito:

  • El backend es un único binario de Go con PocketBase embebido: SQLite, un panel de administración, autenticación, almacenamiento de archivos y realtime, todo en un proceso. Se despliega como imagen de contenedor. Los endpoints propios de los autobuses, como «cuándo pasa el próximo A por esta parada», están junto a las colecciones.
  • Delante hay un Cloudflare Worker en api.cuando.app, con una copia de solo lectura de los datos en D1, el SQLite de Cloudflare. La copia se genera de la forma más simple que se me ocurrió. PocketBase guarda las copias de seguridad como un zip de su archivo SQLite. Las mañanas de los días laborables, una GitHub Action coge la más reciente, le pasa sqlite3 .dump, la arregla con sed y la manda por tubería a wrangler d1 execute. Se salta todo eso si el hash del volcado no ha cambiado. Como los dos lados son SQLite, el Worker incluso ejecuta los mismos archivos .sql que el servidor en Go.
  • La app es Flutter: un único código para Android, iOS y la versión web.
  • El mapa es Mapbox, dibujado con teselas (tiles) ráster, de momento. Ya en septiembre hicimos las cuentas y vimos que «nos quedaríamos sin las 200k peticiones al mes de Static Tiles antes de tener siquiera usuarios». Resultó ser optimista. Los tres nos fundimos la cuota gratuita mensual sin esfuerzo solo probando, y le pagamos a Mapbox entre 10 y 30 $ al mes por una app de la que casi nadie ha oído hablar todavía. Así que lo siguiente que estamos construyendo es un mapa propio. Eso es la segunda parte.

El lanzamiento

Algunas cifras de los últimos seis meses:

  • La landing de cuando.app dijo «Hello, World! ¿Cuando?» durante sus diez primeros días, y era exacto.
  • El pipeline de Google Play llevó 13 commits y unos noventa minutos de montar, la mayoría titulados «attempt». Su número de build es el tiempo Unix dividido entre tres, con un comentario que promete que «debería funcionar hasta el 21 de agosto de 2169». Play no admite version codes por encima de 2100 millones, y lo tenemos previsto.
  • La semana antes del lanzamiento se fue en «cumplimiento normativo»: reescribir cada solicitud de permiso hasta que se explicara sola, y quitar la ubicación en segundo plano.
  • En cifras: unos 450 commits en el backend y 550 en la app. Cinco personas han tocado la app hasta ahora, sobre todo nuestro desarrollador de Flutter, con más de la mitad de sus commits.

Qué viene ahora

  • «¿Cómo llego de A a B?» Ya existe en el servidor como alfa: búsqueda de rutas con hasta dos transbordos, y un tramo a pie de hasta 500 metros entre paradas cercanas cuando eso es más rápido que esperar. Está escrita, lo has adivinado, como otra consulta recursiva. La app todavía no la llama.
  • Mejores horarios, y los informes que nos ayudan a corregirlos.
  • Nuestro propio mapa. Ver arriba: eso es la segunda parte.

Eso es todo

  • Descárgala: cuando.app, con enlaces a Google Play, la App Store y la versión web.
  • Cuéntanos qué está mal: el botón «Informe» de la app, o info@cuando.app.

Y si el autobús sigue sin venir: al menos ahora sabes que va con retraso.

Escrito en septiembre de 2026. Este post lleva la fecha de la semana en que se lanzó Cuando, y está escrito tal como se veía todo entonces. Con veinte meses de perspectiva:
  • ArangoDB nunca volvió. Una sola base de datos fue la decisión correcta.
  • Esa consulta recursiva envejeció mal. Cuando la búsqueda de rutas por fin funcionó sobre D1, a finales de 2025, una búsqueda leía unos dos millones de filas. Y la «búsqueda en profundidad» resultó ser en anchura: las CTE recursivas de SQLite recorren una cola. Los enlaces a pie lo multiplicaban todo. Eso es el post sobre el enrutamiento en SQL.
  • Nuestro propio mapa se puso en marcha cuatro semanas después. Para cuando empezamos a hablarle a la gente de Cuando en serio, todo menos la vista satélite lo dibujábamos nosotros. Eso es la segunda parte.
  • PocketBase cargó con todo hasta la primavera de 2026, en un droplet con una CPU y 1 GB de RAM, y se apagó en julio de 2026.
  • Sigue sin haber un feed oficial, que sepamos. La red dibujada a mano sigue siendo la fuente de verdad, y en 2026 se convirtió en un feed GTFS para un motor de enrutamiento de verdad.
  • La app de Flutter se está reescribiendo en Swift.
  • «El horario es aproximado» sigue en la app, y sigue siendo cierto.