하이브리드 아키텍처 : Supabase와 Spring Boot로 얻는 두 세계의 최고

게시: 14 January 2026

읽기 시간 : 12 minutes

Supabase의 간결함과 Spring Boot의 강력함 사이에서 선택하기보다 왜 두 가지를 결합하지 않을까요? 각 기술의 장점을 활용하는 하이브리드 아키텍처를 살펴보세요.

똑

[]

현대 건축의 가짜 딜레마

정적 프론트엔드를 사용해 현대적인 애플리케이션을 구축할 때, 종종 이진 선택에 직면하게 됩니다 :

  • 백엔드-어즈-어-서비스 솔루션에 모든 것을 걸다(Supabase, Firebase) - 간단하지만 제한적

  • 전체 백엔드 구축하기(Spring Boot, Node.js) - 강력하지만 복잡한

이 선택은 가짜 딜레마입니다. 하이브리드 아키텍처는 세 번째 길을 제시합니다: 각 기술을 그들이 가장 잘하는 곳에 사용하는 것.

건축 비전

전통적인 건축: 일체형

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "전통적인 건축" {
  actor Utilisateur as user
  component "프론트엔드" as frontend #LightBlue
  component "모놀리식 백엔드" as backend #LightCoral {
    [Authentification]
    [CRUD]
    [Logique Métier]
    [Jobs]
    [APIs Tierces]
  }
  database "데이터베이스" as db #LightGray

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

note right of backend
  Tout passe par le backend
  même les opérations simples

  ⚠️ Point de congestion unique
  ⚠️ Complexité dès le départ
  ⚠️ Couplage fort
end note
@enduml

이 접근 방식에서는 가장 간단한 작업(글 읽기, 댓글 작성)이라 할지라도 백엔드를 경유해야 하며, 첫날부터 복잡성의 비용을 지불하게 됩니다.

BaaS 아키텍처: 모든 대리자

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "순수 BaaS 아키텍처" {
  actor Utilisateur as user
  component "프론트엔드" 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
  Développement rapide
  Pas de serveur à gérer

  ⚠️ Limité pour logique complexe
  ⚠️ Vendor lock-in
  ⚠️ Edge Functions contraintes
end note
@enduml

반면에, BaaS에 모든 것을 위임하는 것은 처음에는 매력적이지만, 비즈니스 로직이 복잡해지면 곧 한계가 드러납니다.

하이브리드 아키텍처 : 책임 분리

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

actor Utilisateur as user #LightBlue

package "프론트엔드 레이어" {
  component "정적 사이트 JBake" as frontend #SkyBlue
}

package "단순 레이어 (Supabase)" #LightGreen {
  component "인증" as auth
  component "CRUD 기본" as crud
  component "파일 저장" as storage
  component "실시간" as realtime
}

package "비즈니스 계층 (Spring Boot)" #Coral {
  component "복잡한 논리" as logic
  component "편곡" as orchestration
  component "예약된 작업" as jobs
  component "통합" as integrations
}

database "PostgreSQL 공유" 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
  **Une seule source de vérité**
  Partagée entre Supabase et Spring Boot
end note

note right of auth
  **Gratuit jusqu'à 50k users**
  Configuration en quelques clics
  OAuth2 multi-providers
end note

note right of logic
  **Activé seulement si nécessaire**
  Kotlin + Coroutines
  Transactions complexes
end note
@enduml

하이브리드 아키텍처는 복잡성과 운영의 특성에 따라 책임을 명확히 분리한다.

디자인 원칙

원칙 1: 간단히 시작하고, 지능적으로 발전하기

@startuml
skinparam backgroundColor #FEFEFE

rectangle "1단계 : MVP" #LightGreen {
  component "JBake + Supabase" as mvp
  note right
    ✓ Développement en jours
    ✓ Coût : 0€
    ✓ Validation concept
  end note
}

rectangle "**2단계 : 성장**" #LightYellow {
  component "JBake + Supabase
+ Spring Boot (옵션)" as growth
  note right
    ✓ Logique métier émerge
    ✓ Premiers jobs planifiés
    ✓ Intégrations tierces
  end note
}

rectangle "**3단계 : 확대**" #LightCoral {
  component "완전한 아키텍처" as scale
  note right
    ✓ Orchestration complexe
    ✓ Performances optimisées
    ✓ Cache distribué
  end note
}

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

필요하지 않다면 Spring Boot을 구축하지 마세요.Supabase로 시작하고, 복잡성이 이를 정당화할 때 Spring Boot를 추가하세요.

원칙 2: 작업의 성격에 따른 분리

@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

원칙 3 : 단 하나의 진실의 원천

@startuml
skinparam backgroundColor #FEFEFE

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

  package "스키마: 공개 (공유)" #SkyBlue {
    [articles]
    [comments]
    [profiles]
  }

  package "스키마: 비즈니스 (Spring Boot)" #Coral {
    [orders]
    [payments]
    [reports]
  }
}

component "수퍼베이스" as supabase #LightGreen
component "스프링 부트" 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
  **Avantages :**
  • Pas de synchronisation complexe
  • JOINs possibles entre tables
  • Cohérence garantie
  • Migrations unifiées
end note
@enduml

PostgreSQL 동일한 인스턴스를 공유함으로써, Supabase와 Spring Boot는 복잡한 동기화 없이 동일한 데이터에서 작업합니다.

흐름 오케스트레이션

플럭스 1 : 중앙 집중식 인증

@startuml
skinparam backgroundColor #FEFEFE
autonumber

actor "사용자" as user
participant "JBake" as jbake
participant "Supabase Auth" as auth
participant "스프링 부트" as spring
database "PostgreSQL" as db

== Authentification ==
user -> jbake : Clique "로그인"
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\nvérifie le JWT automatiquement
  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
  **Le JWT est universel**
  Valide par Supabase ET Spring Boot
  Pas de double authentification
end note
@enduml

핵심 포인트: 하나의 인증 프로세스, 하나의 JWT, 어디에서나 사용 가능.

플럭스 2 : 복잡한 비즈니스 프로세스의 오케스트레이션

@startuml
skinparam backgroundColor #FEFEFE
autonumber

actor "클라이언트" as user
participant "JBake" as jbake
participant "스프링 부트" as spring
participant "Supabase DB" as supadb
participant "스트라이프 API" as stripe
participant "재고 서비스" as inventory
participant "이메일 서비스" 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: Notification temps réel\nvia Supabase Realtime
end

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

note over spring
  **Responsabilités Spring Boot :**
  • Transaction ACID
  • Orchestration multi-services
  • Rollback automatique si erreur
  • Gestion des cas limites
end note
@enduml

Spring Boot가 제공하는 것: 여러 시스템을 포함하는 복잡한 프로세스의 신뢰할 수 있는 오케스트레이션, 트랜잭션 보장과 함께.

Flux 3 : 예약된 작업 및 동기화

@startuml
skinparam backgroundColor #FEFEFE

participant "스케줄러\n(Spring Boot)" as scheduler
participant "리포트 서비스" as report
participant "PostgreSQL" as db
participant "외부 API" as api
participant "이메일 서비스" as email
participant "Supabase 스토리지" 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
  **Impossible avec Supabase seul**
  Edge Functions non adaptées
  pour jobs longs et récurrents
end note
@enduml

Spring Boot가 제공하는 것: 상태 관리, 자동 재시도, 보장된 실행을 제공하는 신뢰할 수 있는 예약 작업

의사결정 매트릭스

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

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

프로젝트 유형별 건축 예시

블로그 / 포트폴리오

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "개인 블로그 - 95% Supabase" {
  component "JBake" as jbake #SkyBlue

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

  package "Spring Boot (선택 사항)" #LightCoral {
    [Newsletter Mensuelle]
    note bottom: Job planifié uniquement
  }

  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 (선택 사항)"
  **Spring Boot pas obligatoire**
  Newsletter peut être gérée
  par un service tiers (Mailchimp)
end note
@enduml

판결: 100% Supabase면 충분합니다.

SaaS 애플리케이션

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "SaaS 애플리케이션 - 하이브리드 아키텍처" {
  component "JBake / React" as frontend #SkyBlue

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

  package "스프링 부트" #Coral {
    [Facturation (Stripe)]
    [Analytics Avancées]
    [Rapports Mensuels]
    [Quotas & Limites]
    [Webhooks Stripe]
  }

  cloud "외부 서비스" {
    [Stripe API]
    [SendGrid Email]
  }

  database "공유된 PostgreSQL" 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 "스프링 부트"
  **Nécessaire pour :**
  • Gestion abonnements
  • Facturation récurrente
  • Quotas dynamiques
  • Analytics complexes
  • Webhooks fiables
end note
@enduml

평결: 필요한 하이브리드 아키텍처. Supabase는 주로 사용하고, Spring Boot는 중요한 부분(결제, 청구)에 사용합니다.

전자상거래

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "전자상거래 - 70% Spring Boot" {
  component "스토어프론트 (JBake/React)" as frontend #SkyBlue

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

  package "Spring Boot (핵심 비즈니스)" #Coral {
    [Gestion Commandes]
    [Paiements Stripe]
    [Gestion Stock]
    [Calcul Frais Port]
    [Génération Factures]
    [Synchronisation ERP]
    [Emails Transactionnels]
  }

  cloud "통합" {
    [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 (핵심 비즈니스)"
  **Spring Boot indispensable :**
  • Transactions critiques
  • Orchestration complexe
  • Intégrations multiples
  • Conformité légale
  • Jobs de synchronisation
end note
@enduml

판결Spring Boot 필수적입니다. Supabase는 인증 및 카탈로그용으로만 사용합니다.

점진적 마이그레이션 전략

@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
  **Livrable :** Application fonctionnelle
  **Coût :** 0€
  **Temps :** 1-2 semaines
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
    **Migration sélective**
    Seulement ce qui est complexe
  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
  **Architecture finale hybride**
  Supabase + Spring Boot
  en parfaite harmonie
end note
@enduml

비용 및 운영 고려 사항

비용 구조

@startuml
skinparam backgroundColor #FEFEFE

package "예상 월간 비용" {

  rectangle "MVP 단계
(0-1000 사용자)" #LightGreen {
    [JBake (GitHub Pages): 0€]
    [Supabase: 0€]
    [Spring Boot: N/A]
    note bottom: **Total: 0€/mois**
  }

  rectangle "성장 단계
(1k-10k 사용자)" #LightYellow {
    [JBake (GitHub Pages): 0€]
    [Supabase: 0€]
    [Spring Boot (Cloud Run): 20-50€]
    [PostgreSQL (si séparé): 0-30€]
    note bottom: **Total: 20-80€/mois**
  }

  rectangle "단계 규모
(10k-100k 사용자)" #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€/mois**
  }
}

note right of "단계 규모
(10k-100k 사용자)"
  À ce stade, les revenus
  justifient largement les coûts
end note
@enduml

운영 책임

@startuml
skinparam backgroundColor #FEFEFE

package "누가 무엇을 관리하나요?" {

  rectangle "Supabase에서 관리 (0 노력)" #LightGreen {
    [Authentification]
    [Base de données]
    [Backups automatiques]
    [Scaling automatique]
    [Monitoring DB]
    [Sécurité DB]
  }

  rectangle "GitHub에서 관리 (노력 없음)" #SkyBlue {
    [Hébergement site statique]
    [HTTPS/SSL]
    [CDN global]
    [Déploiement automatique]
  }

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

note bottom of "관리 (Spring Boot)"
  **Minimisable avec :**
  • Cloud Run (serverless)
  • Kubernetes (si nécessaire)
  • Services managés (RDS, etc.)
end note
@enduml

결론 : 완벽한 균형

Supabase + Spring Boot 하이브리드 아키텍처는 타협이 아니라, 이것은시너지.

기억해야 할 원칙

@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

이 아키텍처를 언제 선택해야 할까요?

✅ 이 아키텍처는 다음 경우에 이상적입니다 :

  • 당신은 빠르게 시작하고 싶으신가요 (몇 달이 아닌 며칠 안에 MVP를 구현하고 싶으신가요)

  • 당신은 비즈니스 복잡성의 성장을 예상합니다.

  • 당신은 초기 비용을 최소화하고 싶습니다.

  • PostgreSQL을 좋아하고 단일한 진실의 출처를 원합니다.

  • 당신은 비즈니스 코드를 위해 Kotlin과 코루틴을 좋아합니다

  • 완전한 벤더 락인을 피하고 싶어요

❌ 이 아키텍처는 적합하지 않으면:

  • 당신의 프로젝트는 간단하고 그대로 유지될 것입니다 (개인 블로그 → 100% Supabase면 충분합니다)

  • 당신은 이미 확립된 백엔드 스택을 잘 알고 있습니다

  • 전통적인 모노리스를 선호합니다.

  • .NET, Python 또는 백엔드 측 언어가 필요합니다

최종 전체 비전

@startuml
skinparam backgroundColor #FEFEFE

package "완전한 하이브리드 아키텍처" {

  actor "사용자" as users

  rectangle "프론트엔드 (정적)" #SkyBlue {
    [JBake / GitHub Pages]
    note right: Gratuit, CDN global
  }

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

  rectangle "비즈니스 백엔드 (Spring Boot)" #Coral {
    [Orchestration]
    [Jobs Planifiés]
    [Intégrations]
    [Transactions]
    note right
      Activé uniquement
      si nécessaire
    end note
  }

  database "PostgreSQL
단일 진실의 출처" 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

양쪽의 최고

이 아키텍처는 당신에게 다음을 제공합니다:

🚀 Supabase의 속도

  • 시작은 시간 단위로, 주 단위가 아니다.

  • 몇 클릭만으로 OAuth2 인증

  • 자동으로 생성된 REST API

  • 서버 무설정

💪 Spring Boot의 힘

  • 우아한 비동기 코드를 위한 Kotlin과 Coroutines

  • 복잡한 비즈니스 프로세스 오케스트레이션

  • 신뢰할 수 있는 예약된 작업

  • 보장된 ACID 트랜잭션

  • 완전한 Spring 생태계

💰 진보적인 경제

  • 0€로 시작하고 확인

  • 성장에 따르는 비용

  • 조기 과설계 없음

🎯 건축적 유연성

  • 점진적 마이그레이션, 개편 없이

  • 필요한 경우에만 Spring Boot 추가

  • 완전한 벤더 락인 없음

  • 변화 가능한 아키텍처

더 나아가기

기술 자원

Supabase 문서 :

Spring Boot 문서 :

부칙:

  • JWT를 사용한 API 보안

  • PostgreSQL 성능 최적화

  • 점진적인 마이그레이션 패턴

  • 분산 아키텍처에서의 오류 관리

실제 사용 사례

이 하이브리드 아키텍처는 다음에서 성공적으로 사용됩니다 :

  • B2B SaaS: Supabase 인증, Spring Boot 청구

  • 마켓플레이스Supabase 카탈로그, Spring Boot 트랜잭션

  • 콘텐츠 플랫폼: Supabase 문서, Spring Boot 분석

  • 내부 도구: CRUD Supabase, 워크플로우 Spring Boot

시작 체크리스트

Phase 1 - 기초 (1주차)

  • Supabase 계정 만들기 - [ ] PostgreSQL 프로젝트 구성 - [ ] 인증 활성화 (Google, GitHub) - [ ] 초기 스키마 정의 - [ ] 구성 Row Level Security - [ ] JBake에서 API 테스트

2단계 - MVP (2-3주)

  • 메인 페이지 구현 - [ ] OAuth2 인증 통합 - [ ] CRUD 폼 생성 - [ ] Storage를 파일용으로 구성 - [ ] GitHub Pages에 배포 - [ ] 실제 조건에서 테스트하기

Phase 3 - 진화 (필요에 따라)

  • 복잡한 논리 요구 사항 식별 - [ ] 필요하면 Spring Boot 프로젝트를 생성 - [ ] Supabase JWT 검증 구성 - [ ] PostgreSQL Supabase에 연결 - [ ] 복잡한 기능 마이그레이션 - [ ] 예정된 작업 구현 - [ ] Spring Boot 배포 (Cloud Run 등)

피해야 할 안티패턴

❌ 하지 말 것 :

  • Supabase와 Spring Boot 사이의 데이터 복제

  • 두 개의 별도 PostgreSQL 데이터베이스 생성

  • 인증을 직접 코딩하세요

  • Spring Boot를 이용해 간단한 CRUD

  • 초기부터 과도하게 설계하다

  • Supabase의 Row Level Security 무시하기

✅ 더 하다:

  • 단 하나의 PostgreSQL 데이터베이스 공유

  • Supabase가 인증을 관리하도록 두세요

  • 복잡함을 위해서만 Spring Boot을 사용

  • 간단히 시작하고 점차 발전하다

  • 각 기술의 강점을 활용

  • 데이터베이스 수준에서 RLS로 보안 강화하기

발전 전망

새로운 기능 추가

@startuml
skinparam backgroundColor #FEFEFE

rectangle "현재 아키텍처" #SkyBlue {
  [JBake]
  [Supabase]
  [Spring Boot]
}

rectangle "가능한 변화" #LightYellow {

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

  package "모니터링" {
    [Grafana]
    [Prometheus]
    [Sentry]
  }

  package "지속적 통합/지속적 배포" {
    [GitHub Actions]
    [Tests Automatisés]
    [Déploiement Continu]
  }

  package "기능" {
    [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

수평 확장

앱이 성장함에 따라 하이브리드 아키텍처는 자연스럽게 확장됩니다 :

Supabase:

  • 자동으로 수백만 건의 작업까지 확장

  • 읽기 성능을 위한 읽기 복제본

  • 시점 기반 복구 (보안)

스프링 부트 :

  • 로드 밸런서 뒤에 여러 인스턴스

  • Stateless 설계는 수평 확장을 용이하게 합니다.

  • 필요한 경우 쿠버네티스를 오케스트레이션에 사용

PostgreSQL :

  • 대용량 테이블 파티셔닝

  • 연결 풀링 (PgBouncer)

  • 샤딩은 정말로 필요합니다 (희귀함)

건축적 증언

스타트업 SaaS (50k 사용자)

_ 우리는 Supabase로 100% 시작했습니다. 5k 사용자 수준에서 우리는 Stripe 결제 청구와 월간 보고서를 위해 Spring Boot만 추가했습니다. 1년 후, 우리의 운영 중 80%가 여전히 Supabase를 통해 이루어집니다. Spring Boot는 비판적인 부분만 처리합니다. 이러한 분리를 통해 리팩터링 없이 확장이 가능했습니다. _

E-러닝 플랫폼 (10k 사용자)

_ Supabase의 OAuth2 인증 덕분에 3주 개발 시간을 절약할 수 있었습니다. 자동 생성된 API가 전체 강의 카탈로그를 처리합니다. Spring Boot는 PDF 인증서와 진행 이메일에만 사용됩니다. 간단하고 유지보수 가능하며 확장 가능한 아키텍처. </think> ___

B2B 마켓플레이스 (3k 사용자)

_ Spring Boot은 구매자와 판매자 간 거래를 관리합니다(중요). Supabase는 나머지 모든 것을 관리합니다: 프로필, 실시간 메시징, 문서. 그들이 동일한 PostgreSQL 데이터베이스를 공유한다는 사실 덕분에 복잡한 동기화를 피할 수 있습니다. 우리가 한 최고의 아키텍처 선택입니다. _

요약 : 현대 건축 패러다임

Supabase + Spring Boot 하이브리드 아키텍처는 새로운 패러다임을 나타냅니다 :건축 전문화.

@startuml
skinparam backgroundColor #FEFEFE

rectangle "구식 패러다임" #LightCoral {
  card "백엔드 안의 모든 것" {
    [Auth]
    [CRUD]
    [Logique Métier]
    [Jobs]
    [Storage]
    [Realtime]
  }
  note bottom
    Complexité maximale
    dès le jour 1
  end note
}

rectangle "새로운 패러다임" #LightGreen {
  card "Supabase
(편리함)" {
    [Auth]
    [CRUD Simple]
    [Storage]
    [Realtime]
  }

  card "Spring Boot
(차별화)" {
    [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

기본 원칙 :이미 서비스 형태로 존재하는 것을 구축하지 마세요. 당신의 애플리케이션을 차별화하는 요소에 집중하세요.

80/20 법칙

대부분의 응용 프로그램에서:

  • 80%의 작업기본 CRUD → Supabase

  • 20%의 운영비즈니스 로직이 필요 → Spring Boot

이 자연스러운 규칙은 하이브리드 아키텍처를 정당화한다.

@startuml
skinparam backgroundColor #FEFEFE

package "운영 분배" {

  rectangle "80% - 표준 운영" #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% - 비즈니스 로직" #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

최종 결론

하이브리드 아키텍처는 기술적인 타협이 아니라, 그것은전략적 결정.

할 수 있습니다:

  • ✅ 기능적인 MVP로 빠르게 시작하기

  • ✅ 무거운 투자 없이 시장을 검증하세요

  • 복잡도가 요구될 때 점진적으로 발전시키다

  • ✅ 각 단계에서 비용을 관리하세요

  • ✅ 각 기술의 최고를 활용하다

  • ✅ 조기 과도한 엔지니어링 피하기

  • ✅ 미래를 위한 유연성 유지

그녀는 나타냅니다:

  • 🎯실용주의: 각 기술에서 그녀가 뛰어납니다

  • 🚀속도: Time-to-market 최소한의

  • 💰경제: 가치에 맞춘 비용

  • 🔮확장성함께 성장하는 아키텍처

  • 🛡️견고성: 검증되고 신뢰할 수 있는 서비스

당신의 다음 단계

이 아키텍처가 당신에게 와닿는다면, 여기서 시작하는 방법을 알려드릴게요:

  1. Supabase 계정을 만드세요(무료)

  2. 최소한의 데이터 스키마를 정의하세요

  3. OAuth2 인증을 구성하세요

  4. 당신의 첫 번째 JBake 페이지를 API를 소비하도록 생성하세요

  5. GitHub Pages에 배포하세요.

작동 가능한 MVP를 갖게 될 것입니다몇 일.

Spring Boot은 필요할 때 자연스럽게 따라올 것입니다. 그 이전에는 아닙니다.

하이브리드 아키텍처는 필요한 것을 필요한 때에 정확히 만드는 예술이다.

좋은 개발! 🚀

다른 개발자들이 올바른 아키텍처 선택을 할 수 있도록 도움이 될 것 같다면 이 글을 공유해 주세요.

관련 기사

HyperFrames-Gradle : AsciiDoc을 MP4 비디오로 변환
31 May 2026
나의 LLM 소비 감사 : SQLite, OpenCode, Ollama Cloud, 그리고 왜 나의 프로 구독이 세계 시장을 폭발시키는가?
18 May 2026
아키텍처 « 독립 플러그인 + 소비자 루트 » : 왜 내 Gradle 빌드가 중복되는가
14 May 2026
추천 엔진으로서의 Knowledge Graph: 시간 순서의 « 관련 기사 »를 죽인 방법
12 May 2026