Arquitetura Híbrida: O Melhor dos Dois Mundos com Supabase e Spring Boot

Publicado em 14 January 2026

tempo de leitura : 12 minutes

Em vez de escolher entre a simplicidade do Supabase e a potência do Spring Boot, por que não combinar os dois? Descubra uma arquitetura híbrida que aproveite o melhor de cada tecnologia.

tic

(Note: No characters)

O Falso Dilema da Arquitetura Moderna

Quando se constrói uma aplicação moderna com um frontend estático, muitas vezes nos deparamos com uma escolha binária:

  • Apostar tudo numa solução Backend-as-a-Service(Supabase, Firebase) - simples mas limitada

  • Construir um backend completo(Spring Boot, Node.js) - poderoso mas complexo

Esta escolha é um falso dilema. A arquitetura híbrida propõe um terceiro caminho: usar cada tecnologia onde ela se destaca.

Visão arquitetural

A Arquitetura Tradicional: Monolítica

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "Arquitetura 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 "Banco de Dados" as db #LightGray

  user --> frontend
  frontend --> backend : Toutes les requêtes
  backend --> db
}

note right of backend
Tudo passa pelo backend
mesmo as operações simples
⚠️ Ponto único de congestionamento
⚠️ Complexidade desde o início
⚠️ Acoplamento forte
end note
@enduml

Nessa abordagem, mesmo as operações mais simples (leitura de um artigo, criação de um comentário) devem passar pelo seu backend. Você paga o custo da complexidade desde o primeiro dia.

A Arquitetura BaaS : Todo Delegado

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "Arquitetura 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 : Toutes les opérations
}

note right of baas
Desenvolvimento rápido
Sem servidor para gerenciar
⚠️ Limitado para lógica complexa
⚠️ Vendor lock-in
⚠️ Edge Functions restringidas
end note
@enduml

Do outro lado, delegar tudo a um BaaS é sedutor no início, mas mostra rapidamente seus limites assim que a lógica de negócio se complexifica.

A Arquitetura Híbrida : Separação das Responsabilidades

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

actor Utilisateur as user #LightBlue

package "Camada Frontend" {
  component "Site Estático JBake" as frontend #SkyBlue
}

package "Camada Simples (Supabase)" #LightGreen {
  component "Autenticação" as auth
  component "CRUD Básico" as crud
  component "Armazenamento de Arquivos" as storage
  component "Tempo Real" as realtime
}

package "Camada de Negócio (Spring Boot)" #Coral {
  component "Lógica Complexa" as logic
  component "Orquestração" as orchestration
  component "Jobs Agendados" as jobs
  component "Integrações" as integrations
}

database "PostgreSQL Compartilhado" as db #LightGray

user --> frontend

frontend --> auth : OAuth2, JWT
frontend --> crud : Articles, Profils
frontend --> storage : Images, Fichiers
frontend --> realtime : Notifications

frontend --> logic : Calculs, Rapports
frontend --> orchestration : Workflows
logic --> integrations : Stripe, APIs
orchestration --> db
jobs --> db

crud --> db
auth --> db

note bottom of db
**Uma única fonte de verdade**
Compartilhada entre Supabase e Spring Boot
end note

note right of auth
**Gratuito até 50k users**
Configuração em poucos cliques
OAuth2 multi-providers
end note

note right of logic
**Ativado apenas se necessário**
Kotlin + Coroutines
Transações complexas
end note
@enduml

A arquitetura híbrida separa claramente as responsabilidades de acordo com a complexidade e a natureza das operações.

Princípios de Design

Princípio 1 : Começar Simples, Evoluir Inteligentemente

@startuml
skinparam backgroundColor #FEFEFE

rectangle "**Fase 1 : MVP**" #LightGreen {
  component "JBake + Supabase" as mvp
  note right
✓ Desenvolvimento em dias
✓ Custo: 0€
✓ Validação do conceito
  end note
}

rectangle "**Fase 2 : Crescimento**" #LightYellow {
  component "JBake + Supabase\n+ Spring Boot (opcional)" as growth
  note right
✓ Lógica de negócio emerge
✓ Primeiros jobs agendados
✓ Integrações de terceiros
  end note
}

rectangle "**Fase 3 : Scale**" #LightCoral {
  component "Arquitetura Completa" as scale
  note right
✓ Orquestração complexa
✓ Desempenhos otimizados
✓ Cache distribuído
  end note
}

mvp -down-> growth : Quand la complexité\nle justifie
growth -down-> scale : Optimisation\ncontinue
@enduml

Não construa o Spring Boot se você não precisar dele.Comece com o Supabase, adicione o Spring Boot quando a complexidade o justificar.

Princípio 2: Separação por natureza da operação

@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

Princípio 3: Uma Única Fonte de Verdade

@startuml
skinparam backgroundColor #FEFEFE

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

  package "Schema: public (Compartilhado)" #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 : Gère
supabase -down-> sessions : Gère
supabase -down-> articles : Accède
supabase -down-> comments : Accède
supabase -down-> profiles : Accède

spring -down-> articles : Accède
spring -down-> profiles : Accède
spring -down-> orders : Gère
spring -down-> payments : Gère
spring -down-> reports : Gère

note right of db
**Vantagens:**
• Sem sincronização complexa
• JOINs possíveis entre tabelas
• Consistência garantida
• Migrações unificadas
end note
@enduml

Ao compartilhar a mesma instância PostgreSQL, Supabase e Spring Boot trabalham nos mesmos dados sem sincronização complexa.

Orquestração dos Fluxos

Flux 1 : Autenticação Centralizada

@startuml
skinparam backgroundColor #FEFEFE
autonumber

actor "Utilizador" as user
participant "JBake" as jbake
participant "Supabase Auth" as auth
participant "Spring Boot" as spring
database "PostgreSQL" as db

== Authentification ==
user -> jbake : Clique "Iniciar sessão"
jbake -> auth : Redirect OAuth2 (Google/GitHub)
auth -> user : Consent screen
user -> auth : Autorise
auth -> auth : Génère JWT
auth -> jbake : Retourne JWT + Refresh Token
jbake -> jbake : Stocke tokens (sessionStorage)

== Accès aux Ressources ==
group Opération Simple (CRUD)
  user -> jbake : Crée un article
  jbake -> db : POST avec JWT
  note right: Supabase Row Level Security\nverifica o JWT automaticamente
  db -> jbake : Article créé
end

group Opération Complexe (Métier)
  user -> jbake : Génère un rapport
  jbake -> spring : POST /api/reports\navec JWT
  spring -> spring : Valide JWT Supabase
  spring -> spring : Extrait claims (user_id, roles)
  spring -> db : Requêtes complexes
  spring -> jbake : Rapport généré
end

note over auth, spring
**O JWT é universal**
Validado pelo Supabase E Spring Boot
Sem dupla autenticação
end note
@enduml

Ponto-chaveUm único processo de autenticação, um único JWT, utilizável em qualquer lugar.

Fluxo 2 : Orquestração de um Processo de Negócio Complexo

@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 "Inventory Service" as inventory
participant "Email Service" as email
database "PostgreSQL" as db

user -> jbake : Passe commande
jbake -> spring : POST /api/orders/create

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

par Vérifications Parallèles
  spring -> inventory : Vérifier stock
  inventory -> spring : Stock OK
else
  spring -> db : Vérifier profil client
  db -> spring : Client vérifié
end

spring -> stripe : Créer Payment Intent
stripe -> spring : Intent créé (ID: pi_xxx)

spring -> db : Créer Order (status: PENDING)
db -> spring : Order créé

spring -> stripe : Confirmer paiement
stripe -> spring : Paiement confirmé

spring -> db : Update Order (status: PAID)
spring -> inventory : Décrémenter stock
spring -> db : COMMIT TRANSACTION

par Notifications Asynchrones
  spring -> email : Email confirmation
else
  spring -> supadb : Insert notification
  note right: Notificação em tempo real\nvia Supabase Realtime
end

spring -> jbake : Order confirmé
jbake -> user : Affiche confirmation

note over spring
**Responsabilidades do Spring Boot:**
• Transação ACID
• Orquestração multi-serviços
• Rollback automático em caso de erro
• Gestão de casos limite
end note
@enduml

O que o Spring Boot trazOrquestração fiável de processos complexos envolvendo vários sistemas com garantia transacional.

Flux 3 : Jobs Agendados e Sincronizações

@startuml
skinparam backgroundColor #FEFEFE

participant "Scheduler\n(Spring Boot)" as scheduler
participant "Serviço de Relatórios" as report
participant "PostgreSQL" as db
participant "API Externa" as api
participant "Serviço de E-mail" as email
participant "Supabase Storage" as storage

== Job Quotidien : 2h00 ==
activate scheduler
scheduler -> report : Déclenche génération rapport

activate report
report -> db : Récupère données\ndes dernières 24h
db -> report : Dataset

report -> report : Calculs & Agrégations
report -> report : Génération PDF

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

report -> email : Envoie aux admins\navec lien PDF
deactivate report

== Job Hebdomadaire : Dimanche 3h00 ==
scheduler -> report : Synchronisation externe

activate report
report -> api : Fetch données externes
api -> report : Nouvelles données

report -> db : Mise à jour tables
report -> db : Nettoyage données obsolètes
deactivate report

== Job Mensuel : 1er du mois ==
scheduler -> report : Facturation

activate report
report -> db : Liste clients actifs
report -> report : Calcul montants
report -> api : Génération factures (Stripe)
report -> email : Envoi factures
deactivate report

deactivate scheduler

note right of scheduler
**Impossível apenas com Supabase**
Edge Functions não adequadas
para jobs longos e recorrentes
end note
@enduml

O que o Spring Boot traz: Trabalhos agendados confiáveis com gerenciamento de estado, nova tentativa automática e execução garantida

Matriz de Decisão

Quando usar 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

Quando usar o 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

Exemplos de Arquitetura por Tipo de Projeto

Blog / Portfólio

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

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

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

  package "Spring Boot (Opcional)" #LightCoral {
    [Newsletter Mensuelle]
    note bottom: Tarefa agendada apenas
  }

  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 não obrigatório**
Newsletter pode ser gerida
por um serviço terceiro (Mailchimp)
end note
@enduml

veredicto: 100% Supabase basta amplamente.

Aplicação SaaS

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "Aplicação SaaS - Arquitetura 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 "Serviços Externos" {
    [Stripe API]
    [SendGrid Email]
  }

  database "PostgreSQL Compartilhado" 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"
**Necessário para:**
• Gestão de assinaturas
• Faturação recorrente
• Quotas dinâmicas
• Analytics complexos
• Webhooks fiáveis
end note
@enduml

veredicto: Arquitetura híbrida necessária. Supabase para o essencial, Spring Boot para a parte crítica (pagamentos, faturamento).

e-comércio

@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 (Core do Negócio)" #Coral {
    [Gestion Commandes]
    [Paiements Stripe]
    [Gestion Stock]
    [Calcul Frais Port]
    [Génération Factures]
    [Synchronisation ERP]
    [Emails Transactionnels]
  }

  cloud "Integrações" {
    [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 (Core do Negócio)"
**Spring Boot indispensável:**
• Transações críticas
• Orquestração complexa
• Integrações múltiplas
• Conformidade legal
• Jobs de sincronização
end note
@enduml

veredicto: Spring Boot indispensável. Supabase apenas para auth e catálogo.

Estratégia de Migração Progressiva

@startuml
skinparam backgroundColor #FEFEFE

|Semaine 1-2|
start
:Créer projet Supabase;
:Configurer Auth (Google, GitHub);
:Définir schéma PostgreSQL initial;
:Implémenter CRUD de base sur JBake;
:Déployer MVP sur GitHub Pages;
note right
**Entregável:** Aplicação funcional
**Custo:** 0€
**Tempo:** 1-2 semanas
end note

|Semaine 3-4|
:Observer utilisation réelle;
:Identifier limitations;

|Décision|
if (Logique complexe\némerge ?) then (non)
  |Supabase|
  :Continuer avec Supabase seul;
  :Ajouter Edge Functions si besoin;
  stop
else (oui)
  |Spring Boot|
  :Créer projet Spring Boot;
  :Configurer validation JWT Supabase;
  :Migrer logique complexe vers Spring Boot;
  note right
**Migração seletiva**
Apenas o que é complexo
  end note
endif

|Semaines suivantes|
:Déployer Spring Boot (Cloud Run, EC2);
:Connecter à PostgreSQL Supabase;
:Implémenter premiers jobs planifiés;
:Intégrer APIs tierces;

stop

note right
**Arquitetura final híbrida**
Supabase + Spring Boot
em perfeita harmonia
end note
@enduml

Custos e Considerações Operacionais

Estrutura dos custos

@startuml
skinparam backgroundColor #FEFEFE

package "Custos Mensais Estimados" {

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

  rectangle "Fase de Crescimento\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€/mês**
  }

  rectangle "Fase de 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€/mês**
  }
}

note right of "Fase de Scale\n(10k-100k users)"
Neste estágio, as receitas justificam amplamente os custos
end note
@enduml

Responsabilidades Operacionais

@startuml
skinparam backgroundColor #FEFEFE

package "Quem Gere o Quê?" {

  rectangle "Gerido pelo Supabase (0 esforço)" #LightGreen {
    [Authentification]
    [Base de données]
    [Backups automatiques]
    [Scaling automatique]
    [Monitoring DB]
    [Sécurité DB]
  }

  rectangle "Gerido pelo GitHub (0 esforço)" #SkyBlue {
    [Hébergement site statique]
    [HTTPS/SSL]
    [CDN global]
    [Déploiement automatique]
  }

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

note bottom of "A Gerir (Spring Boot)"
**Minimizável com:**
• Cloud Run (serverless)
• Kubernetes (se necessário)
• Serviços gerenciados (RDS, etc.)
end note
@enduml

Conclusão : O Equilíbrio Perfeito

A arquitetura híbrida Supabase + Spring Boot não é um compromisso, é umasinergia.

Os Princípios a Reter

@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

Quando escolher esta arquitetura?

�✅ Esta arquitetura é ideal se:

  • Você quer começar rapidamente (MVP em dias, não em meses)

  • Você antecipa um aumento da complexidade do negócio

  • Você quer minimizar os custos iniciais

  • Você gosta do PostgreSQL e quer uma fonte de verdade única

  • Você aprecia Kotlin e as coroutines para o código de negócios

  • Você quer evitar o vendor lock-in total

❌ Esta arquitetura NÃO é adequada se :

  • Seu projeto é simples e permanecerá simples (blog pessoal → 100% Supabase basta)

  • Você já tem uma stack de backend estabelecida que você domina

  • Você prefere um monolito tradicional

  • Você precisa de .NET, Python ou outra linguagem de backend

Visão Geral Final

@startuml
skinparam backgroundColor #FEFEFE

package "Arquitetura Híbrida Completa" {

  actor "Utilizadores" as users

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

  rectangle "Backend Simples (Supabase)" #LightGreen {
    [Auth OAuth2]
    [CRUD APIs]
    [Storage]
    [Realtime]
    note right
Gratuito até 50k users
Zero configuração de servidor
    end note
  }

  rectangle "Backend de Negócio (Spring Boot)" #Coral {
    [Orchestration]
    [Jobs Planifiés]
    [Intégrations]
    [Transactions]
    note right
Ativado apenas
se necessário
    end note
  }

  database "PostgreSQL\nFonte Única de Verdade" 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
**Uma única base, dois consumidores**
• Supabase para o simples
• Spring Boot para o complexo
• Nenhuma sincronização necessária
end note

@enduml

O Melhor dos Dois Mundos

Esta arquitetura lhe dá :

🚀 A Velocidade do Supabase

  • Início em horas, não em semanas

  • Autenticação OAuth2 em poucos cliques

  • APIs REST geradas automaticamente

  • Configuração zero do servidor

A Potência do Spring Boot

  • Kotlin e Corrotinas para código assíncrono elegante

  • Orquestração de processos de negócios complexos

  • Trabalhos agendados fiáveis

  • Transações ACID garantidas

  • Ecossistema Spring completo

�💰 A economia progressiva

  • 0€ para iniciar e validar

  • Custos que acompanham o crescimento

  • Sem sobreengenharia prematura

�🎯 Flexibilidade Arquitetural

  • Migração progressiva sem reestruturação

  • Adição do Spring Boot apenas se necessário

  • Sem vendor lock-in total

  • Arquitetura evolutiva

Para Ir Mais Longe

Recursos Técnicos

Documentação Supabase:

Documentação Spring Boot :

Artigos Complementares:

  • Segurança das APIs com JWT

  • Otimização do desempenho do PostgreSQL

  • Padrões de migração progressiva

  • Gestão de erros em arquitetura distribuída

Casos de uso reais

Esta arquitetura híbrida é utilizada com sucesso em:

  • SaaS B2B: Autenticação Supabase, faturação Spring Boot

  • Mercados: Catálogo Supabase, transações Spring Boot

  • Plataformas de conteúdo: Artigos Supabase, analytics Spring Boot

  • Ferramentas internas: CRUD Supabase, fluxos de trabalho Spring Boot

Checklist de inicialização

Fase 1 - Fundações (Semana 1)

  • Criar conta Supabase - [ ] Configurar projeto PostgreSQL - [ ] Ativar Auth (Google, GitHub) - [ ] Definir esquema inicial - [ ] Configurar Row Level Security Testar APIs desde o JBake

Phase 2 - MVP (Semana 2-3)

  • Implementar páginas principais - [ ] Integrar autenticação OAuth2 - [ ] Criar formulários CRUD - [ ] Configurar armazenamento para arquivos - [ ] Implantar no GitHub Pages - [ ] Testar em condições reais

Fase 3 - Evolução (Conforme necessidades)

  • Identificar necessidades de lógica complexa - [ ] Criar projeto Spring Boot se necessário - [ ] Configurar validação JWT Supabase - [ ] Conectar ao PostgreSQL Supabase - [ ] Migrar funcionalidades complexas - [ ] Implementar trabalhos programados - [ ] Implantar Spring Boot (Cloud Run, etc.)

Anti-padrões a evitar

�❌ Não fazer :

  • Duplicar os dados entre Supabase e Spring Boot

  • Criar duas bases PostgreSQL separadas

  • Codificar a autenticação você mesmo

  • Usar o Spring Boot para um CRUD simples

  • Exagerar na arquitetura desde o início

  • Ignorar o Row Level Security do Supabase

�✅ Fazer melhor:

  • Compartilhar uma única base PostgreSQL

  • Deixar o Supabase gerenciar a autenticação

  • Usar Spring Boot apenas para a complexidade

  • Começar simples, evoluir progressivamente

  • Explorar as forças de cada tecnologia

  • Proteger com RLS no nível da base de dados

Perspectivas de Evolução

Adição de Novas Capacidades

@startuml
skinparam backgroundColor #FEFEFE

rectangle "Arquitetura Atual" #SkyBlue {
  [JBake]
  [Supabase]
  [Spring Boot]
}

rectangle "Evoluções Possíveis" #LightYellow {

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

  package "Monitoramento" {
    [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
**Arquitetura extensível**
Cada adição é independente
Nenhuma reformulação global necessária
end note
@enduml

escala horizontal

Quando seu aplicativo cresce, a arquitetura híbrida escala naturalmente :

Supabase :

  • Escala automaticamente até milhões de operações

  • Réplicas de leitura para desempenho de leitura

  • Recuperação em um ponto no tempo para segurança

Spring Boot :

  • Múltiplas instâncias atrás do balanceador de carga

  • Design sem estado facilita o escalonamento horizontal

  • Kubernetes para orquestração, se necessário

PostgreSQL:

  • Particionamento para tabelas voluminosas

  • Pooling de conexões (PgBouncer)

  • Sharding realmente necessário (raro)

Testemunhos Arquitetônicos

Startup SaaS (50k usuários)

_ Começamos com 100% Supabase. Com 5k usuários, adicionamos o Spring Boot apenas para a faturação Stripe e os relatórios mensais. Um ano depois, 80% das nossas operações ainda passam pelo Supabase. O Spring Boot gerencia apenas a parte crítica. Esta separação nos permitiu escalar sem refatoração. _

Plataforma E-learning (10k utilizadores)

_ A autenticação OAuth2 do Supabase nos fez economizar 3 semanas de desenvolvimento. As APIs auto-geradas gerenciam todo o nosso catálogo de cursos. O Spring Boot serve apenas para os certificados PDF e os e-mails de progresso. Arquitetura simples, manutenível e escalável. _

Marketplace B2B (3k utilizadores)

_ Spring Boot gerencia as transações entre compradores e vendedores (crítico). Supabase cuida de tudo o resto: perfis, mensagens em tempo real, documentos. O fato de eles compartilharem a mesma base PostgreSQL nos evita qualquer sincronização complexa. Melhor escolha arquitetural que já fizemos. _

Síntese: Um paradigma arquitetural moderno

A arquitetura híbrida Supabase + Spring Boot representa um novo paradigma:a especialização arquitetônica.

@startuml
skinparam backgroundColor #FEFEFE

rectangle "Antigo Paradigma" #LightCoral {
  card "Tudo no Backend" {
    [Auth]
    [CRUD]
    [Logique Métier]
    [Jobs]
    [Storage]
    [Realtime]
  }
  note bottom
Complexidade máxima
desde o dia 1
  end note
}

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

  card "Spring Boot\n(Diferenciação)" {
    [Logique Métier]
    [Jobs]
    [Intégrations]
  }

  note bottom
Complexidade progressiva
adicionada apenas se necessário
  end note
}

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

@enduml

O princípio fondamental :Não construa o que já existe na forma de serviço. Concentre-se no que diferencia sua aplicação.

A Regra dos 80/20

Na maioria das aplicações :

  • 80% das operaçõesSão CRUD padrão → Supabase

  • 20 % das operaçõesrequerem lógica de negócio → Spring Boot

Esta regra natural justifica a arquitetura híbrida.

@startuml
skinparam backgroundColor #FEFEFE

package "Distribuição das Operações" {

  rectangle "80% - Operações Padrão" #LightGreen {
    [Lecture de données]
    [Création d'entités]
    [Mise à jour simple]
    [Suppression]
    [Upload fichiers]
    [Authentification]

    note bottom: **Gerenciado pelo Supabase**
  }

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

    note bottom: **Gerenciado pelo Spring Boot**
  }
}

note right
**Foco ideal :**
Seu tempo de desenvolvimento
concentrado nos 20% que
diferenciam seu produto
end note
@enduml

Conclusão Final

A arquitetura híbrida não é um compromisso técnico, é umadecisão estratégica.

Ela permite que você :

  • �✅ Começar rapidamente com um MVP funcional

  • �✅ Validar seu mercado sem investimento pesado

  • Evoluir gradualmente quando a complexidade o exige

  • �✅ Domine seus custos em cada etapa

  • �✅ Aproveitar o melhor de cada tecnologia

  • Evitar o over-engineering prematuro

  • ✅ Manter a flexibilidade para o futuro

Ela representa :

  • �🎯pragmatismo: Cada tecnologia onde ela se destaca

  • 🚀Velocidade: Tempo de lançamento mínimo

  • �💰economia: Custos alinhados ao valor

  • �🔮Escalabilidade: Arquitetura que cresce com você

  • 🛡️robustez: Serviços comprovados e confiáveis

Seu Próximo Passo

Se esta arquitetura fala com você, aqui está por onde começar :

  1. Crie uma conta Supabase(gratuito)

  2. Defina seu esquema de dados mínimo

  3. Configure a autenticação OAuth2

  4. Crie sua primeira página JBake que consome a API

  5. Implante no GitHub Pages

Você terá um MVP funcional emalguns dias.

Spring Boot virá naturalmente quando você precisar. Não antes.

A arquitetura híbrida é a arte de construir exatamente o que é preciso, quando preciso.

Bom desenvolvimento! 🚀

Compartilhe este artigo se você pensar que pode ajudar outros desenvolvedores a fazer as boas escolhas arquitetônicas.

Artigos relacionados

HyperFrames-Gradle : Transformar o AsciiDoc em Vídeo MP4
31 May 2026
Auditoria do meu Consumo LLM : SQLite, OpenCode, Ollama Cloud, e Por Que Minha Assinatura Profissional Está Explodindo o Mercado Mundial
18 May 2026
A Arquitetura “Plugin Independente + Raiz Consumidor”: Por que meus builds Gradle se duplicam
14 May 2026
O Knowledge Graph como motor de recomendação: como eu matei os « artigos relacionados» cronológicos
12 May 2026