Arquitectura Híbrida : Lo Mejor de los Dos Mundos con Supabase y Spring Boot

Publicado el 14 January 2026

tiempo de lectura : 12 minutes

En lugar de elegir entre la simplicidad de Supabase y la potencia de Spring Boot, ¿por qué no combinar las dos? Descubre una arquitectura híbrida que aprovecha lo mejor de cada tecnología.

El Falso Dilema de la Arquitectura Moderna

Cuando se construye una aplicación moderna con un frontend estático, a menudo nos encontramos frente a una elección binaria

  • Apostar todo en una solución Backend-as-a-Service(Supabase, Firebase) - simple pero limitada

  • Construir un backend completo(Spring Boot, Node.js) - potente pero complejo

Esta elección es un falso dilema. La arquitectura híbrida propone una tercera vía: utilizar cada tecnología donde sobresale.

Visión Arquitectónica

La Arquitectura Tradicional: Monolítica

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "Arquitectura Tradicional" {
  actor Utilisateur as user
  component "Frontend" as frontend #LightBlue
  component "Backend monolítico" as backend #LightCoral {
    [Authentification]
    [CRUD]
    [Logique Métier]
    [Jobs]
    [APIs Tierces]
  }
  database "Base de datos" as db #LightGray

  user --> frontend
  frontend --> backend : Todas las solicitudes
  backend --> db
}

note right of backend
Todo pasa por el backend
Incluso las operaciones simples
⚠️ Punto único de congestión
⚠️ Complejidad desde el inicio
⚠️ Acoplamiento fuerte
end note
@enduml

En este enfoque, incluso las operaciones más simples (lectura de un artículo, creación de un comentario) deben pasar por su backend. Paga el costo de la complejidad desde el primer día.

La Arquitectura BaaS: Todo Delegado

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "Arquitectura BaaS Pure" {
  actor Utilisateur as user
  component "Frontend" as frontend #LightBlue
  cloud "Supabase / Firebase" as baas #LightGreen {
    [Auth]
    [Database]
    [Storage]
    [Edge Functions]
  }

  user --> frontend
  frontend --> baas : Todas las operaciones
}

note right of baas
Desarrollo rápido
Sin servidor que administrar
⚠️ Limitado para lógica compleja
⚠️ Bloqueo del proveedor
⚠️ Restricciones de Edge Functions
end note
@enduml

Por el contrario, delegar todo a un BaaS es atractivo al principio, pero muestra rápidamente sus límites cuando la lógica de negocio se complica.

La Arquitectura Híbrida: Separación de Responsabilidades

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

actor Utilisateur as user #LightBlue

package "Capa Frontend" {
  component "Sitio Estático JBake" as frontend #SkyBlue
}

package "Capa Simple (Supabase)" #LightGreen {
  component "Autenticación" as auth
  component "CRUD Básico" as crud
  component "Almacenamiento de archivos" as storage
  component "Tiempo Real" as realtime
}

package "Capa de negocio (Spring Boot)" #Coral {
  component "Lógica Compleja" as logic
  component "Orquestación" as orchestration
  component "Trabajos planificados" as jobs
  component "Integraciones" as integrations
}

database "PostgreSQL Compartido" as db #LightGray

user --> frontend

frontend --> auth : OAuth2, JWT
frontend --> crud : Artículos, Perfiles
frontend --> storage : Imágenes, Archivos
frontend --> realtime : Notificaciones

frontend --> logic : Cálculos, Informes
frontend --> orchestration : Flujos de trabajo
logic --> integrations : Stripe, APIs
orchestration --> db
jobs --> db

crud --> db
auth --> db

note bottom of db
**Una única fuente de verdad**
Compartido entre Supabase y Spring Boot
end note

note right of auth
**Gratis hasta 50k usuarios**
Configuración en pocos clics
OAuth2 multi-proveedores
end note

note right of logic
Activado solo si necesario
Kotlin + Coroutines
Transacciones complejas
end note
@enduml

La arquitectura híbrida separa claramente las responsabilidades según la complejidad y la naturaleza de las operaciones.

Principios de Diseño

Principio 1: Empezar de forma simple, evolucionar inteligentemente

@startuml
skinparam backgroundColor #FEFEFE

rectangle "**Fase 1 : MVP**" #LightGreen {
  component "JBake + Supabase" as mvp
  note right
✓ Desarrollo en días
✓ Costo: 0€
✓ Validación del concepto
  end note
}

rectangle "**Fase 2 : Crecimiento**" #LightYellow {
  component "JBake + Supabase\n+ Spring Boot (opcional)" as growth
  note right
✓ Lógica de negocio surge
✓ Primeros trabajos programados
✓ Integraciones de terceros
  end note
}

rectangle "**Fase 3 : Escala**" #LightCoral {
  component "Arquitectura Completa" as scale
  note right
✓ Orquestración compleja
✓ Rendimientos optimizados
✓ Caché distribuido
  end note
}

mvp -down-> growth : Cuando la complejidad\nlo justifica
growth -down-> scale : Optimización\nContinuar
@enduml

No construyas Spring Boot si no lo necesitas.Empieza con Supabase, agrega Spring Boot cuando la complejidad lo justifique.

Principio 2 : Separación por naturaleza de operación

@startmindmap
skinparam backgroundColor #FEFEFE
* Opérations\nApplicatives

left side

** Opérations Simples\n(Supabase)
***_ CRUD Standard
****_ Lecture
****_ Création
****_ Mise à jour
****_ Suppression
***_ Authentification
****_ Login/Logout
****_ OAuth2
****_ Gestion session
***_ Stockage
****_ Upload fichiers
****_ CDN automatique
***_ Temps Réel
****_ WebSocket
****_ Notifications

right side

** Opérations Complexes\n(Spring Boot)
***_ Logique Métier
****_ Calculs complexes
****_ Règles métier
****_ Validations avancées
***_ Orchestration
****_ Multi-services
****_ Transactions distribuées
****_ Saga patterns
***_ Tâches Planifiées
****_ Rapports périodiques
****_ Synchronisations
****_ Nettoyages
***_ Intégrations
****_ Paiements (Stripe)
****_ APIs tierces
****_ Services ML/AI

@endmindmap

Principio 3: Una única fuente de verdad

@startuml
skinparam backgroundColor #FEFEFE

database "PostgreSQL" as db #LightGray {
  package "Schema: auth (Supabase)" #LightGreen {
    [users]
    [sessions]
    [identities]
  }

  package "Schema: public (Compartido)" #SkyBlue {
    [articles]
    [comments]
    [profiles]
  }

  package "Schema: business (Spring Boot)" #Coral {
    [orders]
    [payments]
    [reports]
  }
}

component "Supabase" as supabase #LightGreen
component "Spring Boot" as spring #Coral

supabase -down-> users : gestiona
supabase -down-> sessions : gestiona
supabase -down-> articles : Accede
supabase -down-> comments : Accede
supabase -down-> profiles : Accede

spring -down-> articles : accede
spring -down-> profiles : Accede
spring -down-> orders : gestiona
spring -down-> payments : Administra
spring -down-> reports : gestionaa

note right of db
Ventajas :
• Sin sincronización compleja
• JOINs posibles entre tablas
• Consistencia garantida
• Migraciones unificadas
end note
@enduml

Al compartir la misma instancia de PostgreSQL, Supabase y Spring Boot trabajan con los mismos datos sin una sincronización compleja.

Orquestración de los flujos

Flujo 1 : Autenticación Centralizada

@startuml
skinparam backgroundColor #FEFEFE
autonumber

actor "Usuario" as user
participant "JBake" as jbake
participant "Supabase Autenticación" as auth
participant "Spring Boot" as spring
database "PostgreSQL" as db

== Authentification ==
user -> jbake : Clique "Iniciar sesión"
jbake -> auth : Redirect OAuth2 (Google/GitHub)
auth -> user : Pantalla de consentimiento
user -> auth : Permite
auth -> auth : Genera JWT
auth -> jbake : Devuelve JWT + Token de actualización
jbake -> jbake : Almacena tokens (sessionStorage)

== Accès aux Ressources ==
group Opération Simple (CRUD)
  user -> jbake : Crear un artículo
  jbake -> db : POST con JWT
  note right: Supabase Seguridad a nivel de fila\nverifica el JWT automáticamente
  db -> jbake : Artículo creado
end

group Opération Complexe (Métier)
  user -> jbake : Genera un informe
  jbake -> spring : POST /api/reports\ncon JWT
  spring -> spring : Validar JWT Supabase
  spring -> spring : Extracto reclamaciones (user_id, roles)
  spring -> db : Solicitudes complejas
  spring -> jbake : Informe generado
end

note over auth, spring
**El JWT es universal**
Validado por Supabase y Spring Boot
No double autenticación
end note
@enduml

Punto clave: Un solo proceso de autenticación, un solo JWT, utilizable en todas partes.

Flujo 2: Orquestación de un Proceso de Negocio Complejo

@startuml
skinparam backgroundColor #FEFEFE
autonumber

actor "Cliente" as user
participant "JBake" as jbake
participant "Spring Boot" as spring
participant "Supabase DB" as supadb
participant "Stripe API" as stripe
participant "Servicio de inventario" as inventory
participant "Servicio de correo electrónico" as email
database "PostgreSQL" as db

user -> jbake : Haz un pedido
jbake -> spring : POST /api/orders/create

== Orchestration Spring Boot ==
spring -> db : BEGIN TRANSACTION

par Vérifications Parallèles
  spring -> inventory : Verificar stock
  inventory -> spring : Stock correcto
else
  spring -> db : Verificar perfil del cliente
  db -> spring : Cliente verificado
end

spring -> stripe : Crear Payment Intent
stripe -> spring : Intent creado (ID: pi_xxx)

spring -> db : Crear orden (estado: PENDING)
db -> spring : Order creado

spring -> stripe : Confirmar pago
stripe -> spring : Pago confirmado

spring -> db : Actualizar orden (estado: PAID)
spring -> inventory : Decrementar stock
spring -> db : COMMIT TRANSACTION

par Notifications Asynchrones
  spring -> email : Confirmación de correo electrónico
else
  spring -> supadb : Insertar notificación
  note right: Notificación en tiempo real\nvia Supabase Realtime
end

spring -> jbake : Pedido confirmado
jbake -> user : Mostrar confirmación

note over spring
Responsabilidades de Spring Boot :
- Transacción ACID
- Orquestación multi-servicios
- Rollback automático si error
- Gestión de los casos límites
end note
@enduml

Lo que Spring Boot aporta: Orquestación fiable de procesos complejos que involucran varios sistemas con garantía transaccional.

Flujo 3 : Trabajos Planificados y Sincronizaciones

@startuml
skinparam backgroundColor #FEFEFE

participant "Programador\n(Spring Boot)" as scheduler
participant "Servicio De Reporte" as report
participant "PostgreSQL" as db
participant "Externo API" as api
participant "Servicio De Correo Electrónico" as email
participant "Supabase Almacenamiento" as storage

== Job Quotidien : 2h00 ==
activate scheduler
scheduler -> report : Desencadenar generación informe

activate report
report -> db : Recupera datos\nde las últimas 24h
db -> report : Conjunto de datos

report -> report : Cálculos y agregaciones
report -> report : Generación PDF

report -> storage : Cargar PDF
storage -> report : URL publique

report -> email : Envía a los administradores\ncon el enlace PDF
deactivate report

== Job Hebdomadaire : Domingo 3h00 ==
scheduler -> report : Sincronización externa

activate report
report -> api : Fetch` datos externos
api -> report : nuevos datos

report -> db : Actualización de tablas
report -> db : Limpieza de datos obsoletos
deactivate report

== Job Mensuel : 1.º del mes ==
scheduler -> report : Facturación

activate report
report -> db : Lista clientes activos
report -> report : Cálculo montantes
report -> api : Generación de facturas (Stripe)
report -> email : Envío facturas
deactivate report

deactivate scheduler

note right of scheduler
Imposible solo con Supabase
Edge Functions no adecuadas
para trabajos largos y recurrentes
end note
@enduml

Lo que Spring Boot aporta: Trabajos programados confiables con gestión de estado, reintento automático y ejecución garantizada.

Matriz de Decisión

¿Cuándo utilizar Supabase ?

@startuml
skinparam backgroundColor #FEFEFE

start

:Nouvelle fonctionnalité à implémenter;

if (CRUD simple ?) then (oui)
  :✅ **Supabase**;
  stop
else (non)
  if (Authentification ?) then (oui)
    :✅ **Supabase Auth**;
    stop
  else (non)
    if (Upload fichiers ?) then (oui)
      :✅ **Supabase Storage**;
      stop
    else (non)
      if (Temps réel ?) then (oui)
        :✅ **Supabase Realtime**;
        stop
      else (non)
        if (Row Level Security\nsuffisante ?) then (oui)
          :✅ **Supabase + Policies**;
          stop
        else (non)
          :⚠️ **Considérer Spring Boot**;
          #Coral:Passer à l'arbre\nde décision Spring Boot;
          stop
        endif
      endif
    endif
  endif
endif

@enduml

¿Cuándo usar Spring Boot?

@startuml
skinparam backgroundColor #FEFEFE

start

:Nouvelle fonctionnalité complexe;

if (Orchestration\nmulti-services ?) then (oui)
  :✅ **Spring Boot**;
  stop
else (non)
  if (Transaction ACID\ncritique ?) then (oui)
    :✅ **Spring Boot**;
    stop
  else (non)
    if (Job planifié ?) then (oui)
      :✅ **Spring Boot Scheduler**;
      stop
    else (non)
      if (Intégration API\ntierce complexe ?) then (oui)
        :✅ **Spring Boot**;
        stop
      else (non)
        if (Calculs lourds\n> 10 secondes ?) then (oui)
          :✅ **Spring Boot**;
          stop
        else (non)
          if (Cache distribué\nnécessaire ?) then (oui)
            :✅ **Spring Boot + Redis**;
            stop
          else (non)
            :⚠️ **Probablement Supabase**;
            #LightGreen:Revenir à l'arbre\nde décision Supabase;
            stop
          endif
        endif
      endif
    endif
  endif
endif

@enduml

Ejemplos de Arquitectura por Tipo de Proyecto

Blog / Portafolio

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "Blog Personal - 95% Supabase" {
  component "JBake" as jbake #SkyBlue

  package "Supabase (Gratis)" #LightGreen {
    [Auth: OAuth2 Google]
    [Articles (CRUD)]
    [Commentaires]
    [Images (Storage)]
    [Notifications Realtime]
  }

  package "Spring Boot (Opcional)" #LightCoral {
    [Newsletter Mensuelle]
    note bottom: Trabajo programado únicamente
  }

  database "PostgreSQL" as db

  jbake --> [Auth: OAuth2 Google]
  jbake --> [Articles (CRUD)]
  jbake --> [Commentaires]
  jbake --> [Images (Storage)]
  jbake --> [Notifications Realtime]

  [Articles (CRUD)] --> db
  [Commentaires] --> db
  [Newsletter Mensuelle] --> db
}

note bottom of "Spring Boot (Opcional)"
**Spring Boot no es obligatorio**
El Newsletter puede ser gestionado
por un servicio tercero (Mailchimp)
end note
@enduml

Veredicto: 100% Supabase basta con creces.

Aplicación SaaS

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "Aplicación SaaS - Arquitectura Híbrida" {
  component "JBake / React" as frontend #SkyBlue

  package "Supabase" #LightGreen {
    [Auth Multi-tenant]
    [Profils Utilisateurs]
    [Données Simples]
    [Storage Documents]
  }

  package "Spring Boot" #Coral {
    [Facturation (Stripe)]
    [Analytics Avancées]
    [Rapports Mensuels]
    [Quotas & Limites]
    [Webhooks Stripe]
  }

  cloud "Servicios Externos" {
    [Stripe API]
    [SendGrid Email]
  }

  database "PostgreSQL Compartido" as db

  frontend --> [Auth Multi-tenant]
  frontend --> [Profils Utilisateurs]
  frontend --> [Données Simples]
  frontend --> [Facturation (Stripe)]
  frontend --> [Analytics Avancées]

  [Auth Multi-tenant] --> db
  [Profils Utilisateurs] --> db
  [Données Simples] --> db

  [Facturation (Stripe)] --> db
  [Facturation (Stripe)] --> [Stripe API]
  [Analytics Avancées] --> db
  [Rapports Mensuels] --> db
  [Rapports Mensuels] --> [SendGrid Email]
  [Webhooks Stripe] ..> [Stripe API] : Écoute
}

note right of "Spring Boot"
**Necesario para:**
• Gestión de suscripciones
• Facturación recurrente
• Cuotas dinámicas
• Analytics complejos
• Webhooks fiables
end note
@enduml

Veredicto: Arquitectura híbrida necesaria. Supabase para lo esencial, Spring Boot para la parte crítica (pagos, facturación).

e-commerce

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "E-commerce - 70% Spring Boot" {
  component "Storefront (JBake/React)" as frontend #SkyBlue

  package "Supabase" #LightGreen {
    [Auth Clients]
    [Catalogue Produits\n(lecture seule)]
    [Images Produits]
  }

  package "Spring Boot (Núcleo de Negocio)" #Coral {
    [Gestion Commandes]
    [Paiements Stripe]
    [Gestion Stock]
    [Calcul Frais Port]
    [Génération Factures]
    [Synchronisation ERP]
    [Emails Transactionnels]
  }

  cloud "Integraciones" {
    [Stripe]
    [Transporteur API]
    [ERP Externe]
  }

  database "PostgreSQL" as db

  frontend --> [Auth Clients]
  frontend --> [Catalogue Produits\n(lecture seule)]
  frontend --> [Gestion Commandes]

  [Auth Clients] --> db
  [Catalogue Produits\n(lecture seule)] --> db

  [Gestion Commandes] --> db
  [Paiements Stripe] --> [Stripe]
  [Gestion Stock] --> db
  [Calcul Frais Port] --> [Transporteur API]
  [Génération Factures] --> db
  [Synchronisation ERP] --> [ERP Externe]
  [Synchronisation ERP] --> db
}

note right of "Spring Boot (Núcleo de Negocio)"
**Spring Boot indispensable:**
• Transacciones críticas
• Orquestación compleja
• Integraciones múltiples
• Cumplimiento legal
• Trabajos de sincronización
end note
@enduml

VeredictoSpring Boot indispensable. Supabase solo para auth y catálogo.

Estrategia de migración progresiva

@startuml
skinparam backgroundColor #FEFEFE

|Semaine 1-2|
start
:Crear proyecto Supabase;
:Configurar autenticación (Google, GitHub);
:Definir esquema PostgreSQL inicial;
:Implementar CRUD básico sobre JBake;
:Desplegar MVP en GitHub Páginas;
note right
**Entregable :** Aplicación funcional
**Costo :** 0€
**Tiempo :** 1-2 semanas
end note

|Semaine 3-4|
:Observar uso real;
:Limitaciones del identificador;

|Décision|
if (Logique complexe\némerge ?) then (non)
  |Supabase|
  :Continuar con Supabase solo;
  :Añadir Edge Functions si es necesario;
  stop
else (oui)
  |Spring Boot|
  :Crear proyecto Spring Boot;
  :Configurar validación JWT Supabase;
  :Migrar lógica compleja a Spring Boot;
  note right
**Migración selectiva**
Solo lo que es complejo
  end note
endif

|Semaines suivantes|
:Desplegar Spring Boot (Cloud Run, EC2);
:Conectar a PostgreSQL Supabase;
:Implementar primeros trabajos planificados;
:Integrar APIs terceras;

stop

note right
**Arquitectura híbrida final**
Supabase + Spring Boot
en perfecta armonía
end note
@enduml

Costos y Consideraciones Operacionales

Estructura de costos

@startuml
skinparam backgroundColor #FEFEFE

package "Costes Mensuales Estimados" {

  rectangle "Fase MVP\n(0-1000 users)" #LightGreen {
    [JBake (GitHub Pages): 0€]
    [Supabase: 0€]
    [Spring Boot: N/A]
    note bottom: **Total: 0€/mes**
  }

  rectangle "Fase Crecimiento\n(1k-10k users)" #LightYellow {
    [JBake (GitHub Pages): 0€]
    [Supabase: 0€]
    [Spring Boot (Cloud Run): 20-50€]
    [PostgreSQL (si séparé): 0-30€]
    note bottom: **Total: 20-80€/mes**
  }

  rectangle "Fase Scale\n(10k-100k users)" #LightCoral {
    [JBake (Netlify Pro): 19€]
    [Supabase Pro: 25€]
    [Spring Boot (instances multiples): 100-300€]
    [Redis Cache: 20-50€]
    [Monitoring: 20€]
    note bottom: **Total: 184-414€/mes**
  }
}

note right of "Fase Scale\n(10k-100k users)"
En este punto, los ingresos justifican ampliamente los costes
end note
@enduml

Responsabilidades Operativas

@startuml
skinparam backgroundColor #FEFEFE

package "¿Quién Gestiona Qué?" {

  rectangle "Gestionado por Supabase (0 esfuerzo)" #LightGreen {
    [Authentification]
    [Base de données]
    [Backups automatiques]
    [Scaling automatique]
    [Monitoring DB]
    [Sécurité DB]
  }

  rectangle "Gestionado por GitHub (0 esfuerzo)" #SkyBlue {
    [Hébergement site statique]
    [HTTPS/SSL]
    [CDN global]
    [Déploiement automatique]
  }

  rectangle "A Gestionar (Spring Boot)" #LightCoral {
    [Déploiement application]
    [Monitoring APM]
    [Logs centralisés]
    [Scaling horizontal]
    [Mises à jour sécurité]
  }
}

note bottom of "A Gestionar (Spring Boot)"
**Minimizable con:**
• Cloud Run (serverless)
• Kubernetes (si es necesario)
• Servicios gestionados (RDS, etc.)
end note
@enduml

Conclusión: El Equilibrio Perfecto

La arquitectura híbrida Supabase + Spring Boot no es un compromiso, es unasinergia.

.

@startmindmap
skinparam backgroundColor #FEFEFE
* Architecture\nHybride

** Commencer Simple
***_ MVP avec Supabase
***_ 0€ de coût initial
***_ Validation rapide

** Évoluer Intelligemment
***_ Ajouter Spring Boot\nsi nécessaire
***_ Migration progressive
***_ Pas de refonte totale

** Exploiter les Forces
***_ Supabase: Simplicité
***_ Spring Boot: Puissance
***_ PostgreSQL: Source unique

** Minimiser la Complexité
***_ Pas de synchronisation
***_ Pas de duplication
***_ Architecture claire

** Optimiser les Coûts
***_ Gratuit au départ
***_ Scaling progressif
***_ ROI évident

@endmindmap
@startmindmap
skinparam backgroundColor #FEFEFE
* Architecture\nHybride

** Commencer Simple
***_ MVP avec Supabase
***_ 0€ de coût initial
***_ Validation rapide

** Évoluer Intelligemment
***_ Ajouter Spring Boot\nsi nécessaire
***_ Migration progressive
***_ Pas de refonte totale

** Exploiter les Forces
***_ Supabase: Simplicité
***_ Spring Boot: Puissance
***_ PostgreSQL: Source unique

** Minimiser la Complexité
***_ Pas de synchronisation
***_ Pas de duplication
***_ Architecture claire

** Optimiser les Coûts
***_ Gratuit au départ
***_ Scaling progressif
***_ ROI évident

@endmindmap

¿Cuándo elegir esta arquitectura?

✅ Esta arquitectura es ideal si :

  • Quieres iniciar rápidamente (MVP en días, no en meses)

  • Anticipas un crecimiento de la complejidad del negocio

  • Quieres minimizar los costos iniciales

  • Le gusta PostgreSQL y quiere una única fuente de verdad

  • Tú aprecias Kotlin y las corutinas para el código de negocio

  • Quieres evitar el vendor lock-in total

�❌ Esta arquitectura NO es adecuada si :

  • Tu proyecto es simple y seguirá siéndolo (blog personal → 100% Supabase basta)

  • Ya tienes una pila de backend establecida que dominas

  • Prefiere un monolito tradicional

  • Necesitas .NET, Python u otro lenguaje backend

@startuml
skinparam backgroundColor #FEFEFE

package "Arquitectura Híbrida Completa" {

  actor "Usuarios" as users

  rectangle "Frontend (Estático)" #SkyBlue {
    [JBake / GitHub Pages]
    note right: gratuito, CDN global
  }

  rectangle "Backend Sencillo (Supabase)" #LightGreen {
    [Auth OAuth2]
    [CRUD APIs]
    [Storage]
    [Realtime]
    note right
Gratis hasta 50k usuarios
Cero configuración del servidor
    end note
  }

  rectangle "Backend de Negocio (Spring Boot)" #Coral {
    [Orchestration]
    [Jobs Planifiés]
    [Intégrations]
    [Transactions]
    note right
Activado solo si necesario
    end note
  }

  database "PostgreSQL\nSource Verdad Única" as db #LightGray

  users --> [JBake / GitHub Pages]

  [JBake / GitHub Pages] --> [Auth OAuth2]
  [JBake / GitHub Pages] --> [CRUD APIs]
  [JBake / GitHub Pages] --> [Storage]
  [JBake / GitHub Pages] --> [Realtime]
  [JBake / GitHub Pages] --> [Orchestration]

  [Auth OAuth2] --> db
  [CRUD APIs] --> db
  [Orchestration] --> db
  [Jobs Planifiés] --> db
  [Intégrations] --> db
}

note bottom of db
Una sola base, dos consumidores
• Supabase para lo simple
• Spring Boot para el complejo
• Ninguna sincronización requerida
end note

@enduml
@startuml
skinparam backgroundColor #FEFEFE

package "Arquitectura Híbrida Completa" {

  actor "Usuarios" as users

  rectangle "Frontend (Estático)" #SkyBlue {
    [JBake / GitHub Pages]
    note right: Gratuit, CDN global
  }

  rectangle "Backend sencillo (Supabase)" #LightGreen {
    [Auth OAuth2]
    [CRUD APIs]
    [Storage]
    [Realtime]
    note right
      Gratuit jusqu'à 50k users
      Zéro configuration serveur
    end note
  }

  rectangle "Backend de negocio (Spring Boot)" #Coral {
    [Orchestration]
    [Jobs Planifiés]
    [Intégrations]
    [Transactions]
    note right
      Activé uniquement
      si nécessaire
    end note
  }

  database "PostgreSQL\nFuente Única de la Verdad" as db #LightGray

  users --> [JBake / GitHub Pages]

  [JBake / GitHub Pages] --> [Auth OAuth2]
  [JBake / GitHub Pages] --> [CRUD APIs]
  [JBake / GitHub Pages] --> [Storage]
  [JBake / GitHub Pages] --> [Realtime]
  [JBake / GitHub Pages] --> [Orchestration]

  [Auth OAuth2] --> db
  [CRUD APIs] --> db
  [Orchestration] --> db
  [Jobs Planifiés] --> db
  [Intégrations] --> db
}

note bottom of db
  **Une seule base, deux consommateurs**
  • Supabase pour le simple
  • Spring Boot pour le complexe
  • Aucune synchronisation requise
end note

@enduml

El Mejor de los Dos Mundos

Esta arquitectura le da :

🚀 La velocidad de Supabase

  • Inicio en horas, no en semanas

  • Autenticación OAuth2 en unos pocos clics

  • APIs REST generados automáticamente

  • Cero configuración del servidor

�💪 La potencia de Spring Boot

  • Kotlin y Coroutines para código asíncrono elegante

  • Orquestación de procesos de negocio complejos

  • Trabajos programados fiables

  • Transacciones ACID garantizadas

  • Ecosistema Spring completo

�💰 La Economía Progresiva

  • 0€ para iniciar y validar

  • Costos que siguen el crecimiento

  • No sobreingeniería prematura

🎯 La Flexibilidad Arquitectónica

  • Migración progresiva sin reestructuración

  • Adición de Spring Boot solo si es necesario

  • Sin vendor lock-in total

  • Arquitectura evolutiva

Para ir más lejos

Recursos Técnicos

Documentación Supabase:

Documentación de Spring Boot :

Artículos Complementarios :

  • Seguridad de las APIs con JWT

  • Optimización del rendimiento de PostgreSQL

  • Patrones de migración progresiva

  • Gestión de errores en arquitectura distribuida

Casos de uso reales

Esta arquitectura híbrida se utiliza con éxito en :

  • SaaS B2B: Autenticación Supabase, facturación Spring Boot

  • Mercados: Catálogo Supabase, transacciones Spring Boot

  • Plataformas de contenidoArtículos Supabase, analítica Spring Boot

  • Herramientas internas: CRUD Supabase, workflows Spring Boot

Lista de arranque

Fase 1 - Fundaciones (Semana 1)

  • Crear cuenta Supabase - [ ] Configurar proyecto PostgreSQL - [ ] Activar autenticación (Google, GitHub) - [ ] Definir esquema inicial - [ ] Configurar Row Level Security - [ ] Probar APIs desde JBake

Phase 2 - MVP (Semana 2-3)

  • Implementar páginas principales Integrar autenticación OAuth2 - [ ] Crear formularios CRUD - [ ] Configurar Storage para archivos - [ ] Desplegar en GitHub Pages - [ ] Probar en condiciones reales

Phase 3 - Evolución (Según necesidades)

  • Identificar necesidades de lógica compleja - [ ] Crear proyecto Spring Boot si es necesario - [ ] Configurar validación JWT Supabase - [ ] Conectar a PostgreSQL Supabase - [ ] Migrar funcionalidades complejas - [ ] Implementar trabajos programados - [ ] Desplegar Spring Boot (Cloud Run, etc.)

Antipatrones a Evitar

�❌ No hacer :

  • Duplicar los datos entre Supabase y Spring Boot

  • Crear dos bases de datos PostgreSQL separadas

  • Codificar la autenticación usted mismo

  • Utilizar Spring Boot para CRUD simple

  • Sobrediseñar desde el principio

  • Ignorar la seguridad a nivel de fila de Supabase

Hacer mejor:

  • Compartir una única base de datos PostgreSQL

  • Dejar que Supabase gestione la autenticación

  • Utilizar Spring Boot solo para la complejidad

  • Empezar simple, evolucionar gradualmente

  • Aprovechar las fortalezas de cada tecnología

  • Asegurar con RLS a nivel de base de datos

Perspectivas de Evolución

@startuml
skinparam backgroundColor #FEFEFE

rectangle "Arquitectura Actual" #SkyBlue {
  [JBake]
  [Supabase]
  [Spring Boot]
}

rectangle "Evoluciones Posibles" #LightYellow {

  package "Rendimiento" {
    [Redis Cache]
    [CDN pour Assets]
    [PostgreSQL Replicas]
  }

  package "Monitoreo" {
    [Grafana]
    [Prometheus]
    [Sentry]
  }

  package "CI/CD" {
    [GitHub Actions]
    [Tests Automatisés]
    [Déploiement Continu]
  }

  package "Funcionalidades" {
    [Search (ElasticSearch)]
    [Queue (RabbitMQ)]
    [Event Sourcing]
  }
}

[Spring Boot] .down.> [Redis Cache] : Peut ajouter
[Spring Boot] .down.> [Queue (RabbitMQ)] : Peut ajouter
[Spring Boot] .down.> [Search (ElasticSearch)] : Peut ajouter

[Supabase] .down.> [PostgreSQL Replicas] : Peut ajouter

note bottom
**Arquitectura extensible**
Cada adición es independiente
No es necesario un rediseño global
end note
@enduml
@startuml
skinparam backgroundColor #FEFEFE

rectangle "Arquitectura Actual" #SkyBlue {
  [JBake]
  [Supabase]
  [Spring Boot]
}

rectangle "Evoluciones Posibles" #LightYellow {

  package "rendimiento" {
    [Redis Cache]
    [CDN pour Assets]
    [PostgreSQL Replicas]
  }

  package "Monitoreo" {
    [Grafana]
    [Prometheus]
    [Sentry]
  }

  package "CI/CD" {
    [GitHub Actions]
    [Tests Automatisés]
    [Déploiement Continu]
  }

  package "Funcionalidades" {
    [Search (ElasticSearch)]
    [Queue (RabbitMQ)]
    [Event Sourcing]
  }
}

[Spring Boot] .down.> [Redis Cache] : Peut ajouter
[Spring Boot] .down.> [Queue (RabbitMQ)] : Peut ajouter
[Spring Boot] .down.> [Search (ElasticSearch)] : Peut ajouter

[Supabase] .down.> [PostgreSQL Replicas] : Peut ajouter

note bottom
  **Architecture extensible**
  Chaque ajout est indépendant
  Pas de refonte globale nécessaire
end note
@enduml

Escalado horizontal

Cuando tu aplicación crece, la arquitectura híbrida escala naturalmente :

Supabase :

  • Escala automáticamente hasta millones de operaciones

  • Read replicas para rendimiento de lectura

  • Recuperación en el punto de tiempo para seguridad

Spring Boot :

  • Múltiples instancias detrás del balanceador de carga

  • El diseño sin estado facilita el escalado horizontal

  • Kubernetes para orquestación si es necesario

PostgreSQL :

  • Partitioning para tablas voluminosas

  • Agrupamiento de conexiones (PgBouncer)

  • Sharding si es realmente necesario (raro)

Testimonios Arquitectónicos

Startup SaaS (50k usuarios)

_ Empezamos con Supabase al 100%. Con 5k usuarios, añadimos Spring Boot únicamente para la facturación de Stripe y los informes mensuales. Un año después, el 80% de nuestras operaciones siguen pasando por Supabase. Spring Boot gestiona solo la parte crítica. Esta separación nos permitió escalar sin una reestructuración. _

Plataforma E-learning (10k usuarios)

_ La autenticación OAuth2 de Supabase nos ahorró 3 semanas de desarrollo. Las APIs autogeneradas gestionan todo nuestro catálogo de cursos. Spring Boot solo se utiliza para los certificados PDF y los correos de progreso. Arquitectura simple, mantenible, escalable. _

Marketplace B2B (3k usuarios)

_ Spring Boot gestiona las transacciones entre compradores y vendedores (crítico). Supabase gestiona todo lo demás: perfiles, mensajería en tiempo real, documentos. El hecho de que compartan la misma base de datos PostgreSQL nos evita toda sincronización compleja. Mejor elección arquitectónica que hemos hecho. </think> _

Síntesis: Un paradigma arquitectónico moderno

@startuml
skinparam backgroundColor #FEFEFE

rectangle "Paradigma antiguo" #LightCoral {
  card "Todo en el Backend" {
    [Auth]
    [CRUD]
    [Logique Métier]
    [Jobs]
    [Storage]
    [Realtime]
  }
  note bottom
Complejidad máxima

desde el día 1
  end note
}

rectangle "Nuevo paradigma" #LightGreen {
  card "Supabase\n(Commodité)" {
    [Auth]
    [CRUD Simple]
    [Storage]
    [Realtime]
  }

  card "Spring Boot\n(Différenciation)" {
    [Logique Métier]
    [Jobs]
    [Intégrations]
  }

  note bottom
Complejidad progresiva
agregada solo si es necesario
  end note
}

[Ancien Paradigme] -right-> [Nouveau Paradigme] : Évolution

@enduml
@startuml
skinparam backgroundColor #FEFEFE

rectangle "Antiguo Paradigma" #LightCoral {
  card "Todo en el Backend" {
    [Auth]
    [CRUD]
    [Logique Métier]
    [Jobs]
    [Storage]
    [Realtime]
  }
  note bottom
    Complexité maximale
    dès le jour 1
  end note
}

rectangle "Nuevo Paradigma" #LightGreen {
  card "Supabase\n(Comodidad)" {
    [Auth]
    [CRUD Simple]
    [Storage]
    [Realtime]
  }

  card "Spring Boot\n(Diferenciación)" {
    [Logique Métier]
    [Jobs]
    [Intégrations]
  }

  note bottom
    Complexité progressive
    ajoutée seulement si nécessaire
  end note
}

[Ancien Paradigme] -right-> [Nouveau Paradigme] : Évolution

@enduml

El principio fundamental:No construyas lo que ya existe como servicio. Concéntrate en lo que diferencia tu aplicación.

La regla del 80/20

En la mayoría de las aplicaciones :

  • 80% de las operacionesson estándar CRUD → Supabase

  • 20% de las operacionesnécessiten de la lógica de negocio → Spring Boot

@startuml
skinparam backgroundColor #FEFEFE

package "Distribución de Operaciones" {

  rectangle "80% - Operaciones Estándar" #LightGreen {
    [Lecture de données]
    [Création d'entités]
    [Mise à jour simple]
    [Suppression]
    [Upload fichiers]
    [Authentification]

    note bottom: **Gestionado por Supabase**
  }

  rectangle "20% - Lógica de Negocio" #Coral {
    [Calculs complexes]
    [Workflows multi-étapes]
    [Transactions critiques]
    [Intégrations tierces]
    [Jobs planifiés]

    note bottom: **Gestionado por Spring Boot**
  }
}

note right
**Enfoque óptimo:**
Su tiempo de desarrollo
concentrado en el 20% que
diferencia su producto
end note
@enduml
@startuml
skinparam backgroundColor #FEFEFE

package "Distribución de Operaciones" {

  rectangle "80% - Operaciones estándar" #LightGreen {
    [Lecture de données]
    [Création d'entités]
    [Mise à jour simple]
    [Suppression]
    [Upload fichiers]
    [Authentification]

    note bottom: **Géré par Supabase**
  }

  rectangle "20% - Lógica de Negocio" #Coral {
    [Calculs complexes]
    [Workflows multi-étapes]
    [Transactions critiques]
    [Intégrations tierces]
    [Jobs planifiés]

    note bottom: **Géré par Spring Boot**
  }
}

note right
  **Focus optimal :**
  Votre temps de développement
  concentré sur les 20% qui
  différencient votre produit
end note
@enduml

Conclusión Final

La arquitectura híbrida no es un compromiso técnico, es unadecisión estratégica.

Le permite :

  • ✅ Iniciar rápidamente con un MVP funcional

  • �✅ Validar tu mercado sin una gran inversión

  • Evolucionar gradualmente cuando la complejidad lo exige

  • Domina tus costos en cada etapa

  • Exploitar lo mejor de cada tecnología

  • ✅ Evitar el sobreingeniería prematuro

  • �✅ Mantener la flexibilidad para el futuro

Ella representa :

  • 🎯Pragmatismo: Cada tecnología donde sobresale

  • 🚀Velocidad: Time-to-market mínimo

  • �💰EconomíaCostos alineados con el valor

  • �🔮Escalabilidad: Arquitectura que crece contigo

  • �🛡️Robustez: Servicios probados y fiables

Su Próximo Paso

Si esta arquitectura te habla, aquí está por dónde empezar:

  1. Cree una cuenta Supabase(gratuito)

  2. Define tu esquema de datos mínimo

  3. Configura la autenticación OAuth2

  4. Crea tu primera página JBake que consume la API

  5. Despliega en GitHub Pages

Tendrás un MVP funcional enunos días.

La arquitectura híbrida, es el arte de construir exactamente lo necesario, cuando es necesario.

Artículos relacionados

HyperFrames-Gradle: Convertir AsciiDoc a video MP4
31 May 2026
Auditoría de mi consumo LLM: SQLite, OpenCode, Ollama Cloud, y por qué mi suscripción Pro está revolucionando el mercado mundial
18 May 2026
La arquitectura “Plugin independiente + raíz consumidora”: ¿por qué mis builds de Gradle se duplican?
14 May 2026
El Knowledge Graph como motor de recomendación: cómo maté los « artículos conexos » cronológicos
12 May 2026