Aplicatii web

Arhitectură SaaS Multi-Tenant: Ghid Tehnic 2026 pentru Founders B2B

UP

UP2DATE Team

Software Development

Multi-tenancy este decizia arhitecturală care îți face sau strică SaaS-ul B2B. Aleasă greșit, te trezești la 1.000 de clienți cu o platformă imposibil de scalat și costuri infrastructure de 50.000 EUR/lună. Aleasă corect, scalezi de la 10 la 10.000 clienți pe aceeași arhitectură cu efort marginal.

Acest ghid e pentru founders B2B care planifică să construiască un SaaS în 2026 sau care evaluează re-arhitecturarea unui produs existent. Acoperă: cele 3 strategii multi-tenant (Pool, Bridge, Silo), când alegi PostgreSQL Row-Level Security vs database-per-tenant, cum integrezi Stripe Billing pentru recurring revenue și cum implementezi SSO corporate fără să rescrii autentificarea.

Single-tenant vs Multi-tenant: Decizia inițială

Single-tenant: o instanță software per client. Fiecare client are baza lui de date, server-ele lui, deploy-ul lui dedicat.

Multi-tenant: o singură instanță software servește toți clienții cu data isolation prin logică software.

Hybrid: multi-tenant pentru SMB clients, single-tenant pentru clienții enterprise cu cerințe stricte de securitate.

Comparativ direct:

AspectSingle-tenantMulti-tenant
Cost infrastructureLiniar cu # cliențiSub-liniar (scale economics)
MentenanțăN deploy-uri1 deploy
Update vitezaPer client scheduleGlobal push
Data isolationFizică (perfectă)Logică (depinde de implementare)
Customization clientFoarte flexibilLimitat (per-tenant config)
Cerințe complianceMai ușor pentru data residencyNecesită design atent pentru GDPR
Sweet spotEnterprise B2B mareSMB + mid-market B2B

Regula generală: dacă vinzi la SMB ($50-500/lună), multi-tenant. Dacă vinzi la enterprise ($50.000+/an) cu cerințe stricte, single-tenant sau hybrid.

3 strategii de multi-tenancy: Pool, Bridge, Silo

Pool Model: toți tenants împart aceleași resurse (database, servere, network). Data isolation prin coloana tenant_id în fiecare tabel + middleware care filtrează queries.

  • Pros: cost minim, scale automat
  • Cons: noisy neighbor (un client cu trafic uriaș afectează toți), data isolation depinde de bug-free code
  • Risc: "tenant data leak" cel mai dezastruos accident SaaS

Bridge Model: shared infrastructure, dar fiecare tenant are propria sa schema în database (PostgreSQL schemas). Logic isolated, fizic shared.

  • Pros: data isolation mai puternică decât Pool, încă scale economics
  • Cons: complex migrations (N schemas updates), limită ~1.000 tenants per database
  • Use case: ideal pentru B2B mid-market 100-500 clienți

Silo Model: database separat per tenant (multiple databases pe același server, sau multiple servere). Cel mai aproape de single-tenant dar cu shared app layer.

  • Pros: data isolation aproape fizică, customization per-tenant, compliance ușor
  • Cons: cost infrastructure mai mare, mentenanță complexă
  • Use case: enterprise B2B cu compliance strict (financial, healthcare)

Hybrid recomandat: Pool pentru SMB, Silo pentru enterprise. Codebase unic, deploy diferit per tier client.

PostgreSQL Row-Level Security: Implementare Pool Model

PostgreSQL RLS este cea mai bună soluție în 2026 pentru Pool Model. Garantează data isolation la nivel database, nu doar aplicație.

Cum funcționează:

-- 1. Activează RLS pe fiecare tabel cu date tenant
ALTER TABLE invoices ENABLE ROW LEVEL SECURITY;

-- 2. Creezi policy care filtrează automat după tenant_id
CREATE POLICY tenant_isolation_policy ON invoices
  USING (tenant_id = current_setting('app.current_tenant_id')::uuid);

-- 3. Aplicația setează tenant context la fiecare request
SET app.current_tenant_id = '550e8400-e29b-41d4-a716-446655440000';

-- 4. Query-urile automate filtrează — nu mai ai nevoie de WHERE tenant_id = ...
SELECT * FROM invoices; -- returnează DOAR facturile tenantului curent

Avantajele RLS vs filtering în aplicație:

  • Imun la bug-uri developer care uită WHERE tenant_id într-un query
  • Audit log database-level: vezi exact ce tenant a accesat ce data
  • Funcționează automat pentru toate ORM-urile (Eloquent, Prisma, TypeORM)

Capcane comune:

  • Migrations rulează ca superuser care BYPASS RLS — atenție la scripts
  • Connection pooling (PgBouncer) cu transaction mode = SET-ul de tenant context se pierde între queries; folosește session mode
  • Performance: index pe tenant_id obligatoriu, plus partition mare-volume tables după tenant_id

Database-per-tenant: Când și cum

Alegi database-per-tenant (Silo Model) când:

  1. Cerințe compliance strict — GDPR data residency, HIPAA, financial regulations
  2. Tenants care plătesc 10.000+ EUR/lună (justifică cost infrastructure)
  3. Customization profundă per-tenant — schemas diferite, integrări diferite
  4. Backup/restore independent per tenant

Arhitectură recomandată:

┌─────────────────────────────────────────┐
│  Application Layer (Stateless)          │
│  - Routing tenant request → DB conn     │
└────────────┬────────────────────────────┘
             │
    ┌────────┴────────┐
    │  Connection Pool │ (per tenant)
    └────────┬────────┘
             │
   ┌─────────┼─────────┐
   ▼         ▼         ▼
┌─────┐   ┌─────┐   ┌─────┐
│ DB1 │   │ DB2 │   │ DB3 │  (cluster Postgres multi-DB)
└─────┘   └─────┘   └─────┘

Tooling 2026:

  • Citus (PostgreSQL extension) — shard per tenant_id, transparent pentru aplicație
  • Neon — branching per tenant, copy-on-write, cost ~0.10 EUR/lună per tenant inactiv
  • AWS RDS cu schema-per-tenant + IAM role per tenant pentru data isolation

Stripe Billing pentru SaaS recurring revenue

Billing-ul în SaaS B2B e complex: plan tiers, trial periods, prorated upgrades/downgrades, usage-based billing, dunning automation, webhook events. Stripe Billing acoperă 95% din cazuri out-of-the-box.

Setup recomandat:

1. Products + Prices arhitectură

  • Un Product per plan tier (Starter, Pro, Enterprise)
  • Multiple Prices per Product (lunar, anual cu discount, usage-based component)
  • Niciodată hardcode prețuri în cod — toate în Stripe Dashboard pentru flexibilitate

2. Customer + Subscription flow

# 1. La signup, creezi Customer în Stripe
customer = stripe.Customer.create(
    email=tenant.admin_email,
    metadata={"tenant_id": tenant.id}
)

# 2. Trial period (Stripe gestionează automat)
subscription = stripe.Subscription.create(
    customer=customer.id,
    items=[{"price": "price_starter_monthly"}],
    trial_period_days=14,
    metadata={"tenant_id": tenant.id}
)

# 3. Webhook listener pentru events critice
@app.post("/webhooks/stripe")
def handle_stripe_webhook(event):
    if event.type == "customer.subscription.trial_will_end":
        send_email(...)  # Reminder înainte de trial end
    elif event.type == "invoice.payment_failed":
        trigger_dunning_flow(...)  # Retry + email client
    elif event.type == "customer.subscription.deleted":
        downgrade_to_free_tier(tenant)

3. Usage-based billing (opțional)

Pentru SaaS cu API calls sau storage:

stripe.SubscriptionItem.create_usage_record(
    subscription_item_id,
    quantity=monthly_api_calls,
    timestamp=int(time.time()),
    action="set"
)

Stripe agregă automat pe ciclu de billing și facturează corect.

Capcane comune:

  • NU sincroniza Stripe data în DB ta — Stripe este source of truth, query-uiește live
  • Webhook idempotency: folosește event.id ca primary key în tabel processed_events
  • PSD2 SCA: pentru clienți EU, configurează 3D Secure în Stripe pentru tranzacții peste 30 EUR

SSO și autentificare corporate

La 1.000 EUR/lună+ pricing, clienții enterprise cer Single Sign-On (SSO) ca prerequisite. Fără SSO, nu vinzi la enterprise.

3 protocoale principale:

1. SAML 2.0 — standard enterprise, mai vechi dar omniprezent

  • Compatibilitate: Azure AD, Okta, OneLogin, Active Directory
  • Implementare: bibliotecă python3-saml sau passport-saml în Node.js

2. OAuth 2.0 + OpenID Connect (OIDC) — modern, JSON-based, mai simplu

  • Compatibilitate: Azure AD, Google Workspace, Okta
  • Implementare: Auth0, Keycloak, sau direct cu library-uri standard

3. JWT-based custom SSO — pentru integrări cu sisteme corporate vechi

  • Rar dar necesar uneori

Pattern recomandat 2026: Auth0 sau Keycloak

Auth0 ($23/lună pentru 1.000 utilizatori activi) îți dă:

  • Integrare SAML, OAuth, OIDC fără efort
  • User management UI gata
  • Rules + Hooks pentru logică custom
  • Compliance SOC 2, ISO 27001 gata pentru audit enterprise

Keycloak (self-hosted, gratis) îți dă același feature set dar trebuie mentenanță.

Capcane:

  • NU folosi un singur cont SSO per tenant — fiecare utilizator din tenant trebuie să aibă cont separat
  • Just-In-Time Provisioning: când un utilizator nou face SSO, creezi automat cont local cu rolul mapat din claims
  • Group/Role sync: claims SAML/OIDC trebuie mapate la roluri în aplicația ta

Costuri estimative pentru SaaS B2B în 2026

Early-stage (10-50 tenants, Pool Model):

  • AWS infrastructure: 200-500 EUR/lună
  • Stripe Billing: 2.9% + 0.30 EUR per tranzacție
  • Auth0/Keycloak: 0-100 EUR/lună
  • Observability (Sentry, Datadog): 50-200 EUR/lună
  • Total: 500-1.200 EUR/lună

Scale-up (100-500 tenants, Bridge Model):

  • Infrastructure: 1.500-4.000 EUR/lună
  • Total operaționale: 3.000-7.000 EUR/lună

Enterprise (500-2.000 tenants, Hybrid Pool+Silo):

  • Infrastructure: 8.000-20.000 EUR/lună
  • Total operaționale: 15.000-30.000 EUR/lună

Stack tehnologic recomandat 2026

Pentru SaaS B2B nou în 2026, recomandare bazată pe maturitate ecosistem + comunitate:

Backend: Laravel 11 (PHP 8.3) sau NestJS (TypeScript). Both au pattern-uri multi-tenant mature, ORM puternic, ecosystem matur.

Frontend: Next.js 15 (App Router) cu shadcn/ui. SSR pentru SEO, RSC pentru performance, ecosystem cel mai bogat.

Database: PostgreSQL 16 cu Row-Level Security. Sau Neon pentru DB branching per tenant.

Cache + Queues: Redis (sau Upstash pentru serverless).

Search: Meilisearch (self-hosted) sau Algolia (managed).

Storage: AWS S3 sau Cloudflare R2 (mai ieftin).

Monitoring: Sentry + Datadog sau Grafana Cloud.

Deploy: AWS ECS Fargate sau Vercel (frontend) + AWS ECS (backend). Kubernetes doar la 100+ servicii.

Concluzie: Foaia de drum pentru un SaaS B2B în 2026

  1. Discovery (1-2 săpt): alegi multi-tenancy strategy bazat pe ICP (Ideal Customer Profile)
  2. Arhitectură (1 săpt): design data isolation, billing, auth flow
  3. MVP (10-14 săpt): Pool Model + PostgreSQL RLS + Stripe Billing + Auth0
  4. First customers (luna 4-6): iterare pe feedback, monitoring engagement
  5. Scale (luna 12+): dacă peste 500 tenants, evaluați migrare la Bridge Model

La UP2DATE Software construim platforme SaaS B2B production-ready în 12-16 săptămâni — arhitectură multi-tenant aleasă pe baza ICP-ului tău, Stripe Billing recurent inclus din primul sprint, SSO corporate ready, admin panel rich pentru subscription management. Pentru founders care vor să lanseze cu primii clienți plătitori rapid, nu să construiască infrastructure pentru 6 luni.

Pentru Discovery Workshop SaaS B2B și estimare detaliată, discută cu echipa noastră — răspuns în 24 ore.

UP

Echipa UP2DATE Software

Companie de dezvoltare software din România cu experiență în aplicații mobile, aplicații web și automatizări AI pentru business. Ajutăm companiile să se digitalizeze și să crească prin tehnologie.

Despre noi →Contact →