The $18,000/yr B2B SSO Tax Dilemma

Auth0 Enterprise SSO Wall vs WorkOS & Self-Hosted SAML

Calculate the real unit economics when enterprise procurement demands Okta SAML 2.0 and SCIM directory sync. Compare Auth0's $15k–$24k minimum annual contract against WorkOS ($125/connection) and self-hosted BoxyHQ Jackson.

Quick Scenarios:
Enterprise Identity Architecture
Adjust customer connections, user counts, and protocols
Enterprise SAML 2.0 / OIDC Connections 1 Connection
1 Okta/Entra Org 25 Connections 50 Connections
Active Users in Enterprise Tenants 100 Users
50 Users 10k Users 25,000 Users
SCIM 2.0 Automated User Provisioning 0 Connections
0 (Manual JIT) 20 Orgs 40 Orgs
Auth0 Annual Minimum Commitment $18,000 / year
$12k/yr $18k/yr (Avg) $36k/yr
Self-Hosted Proxy Compute (BoxyHQ Jackson)
Billing Horizon Model
Auth0 Enterprise Annual
$18,000
$1,500 / mo per customer
WorkOS Pay-As-You-Go
$1,500
$125 / mo per customer
Self-Hosted Jackson
$240
98.7% vs Auth0
Annual Spend by Enterprise Provider
Comparing mandatory contract commitments vs unit-metered billing
Auth0
WorkOS
Self-Hosted
$40k $30k $20k $10k $0 $18,000 Auth0 Enterprise $1,500 WorkOS SSO $240 Self-Hosted Jackson
Cost Waterfall & Unit Economics (Annual Horizon)
Fee Category Auth0 Enterprise WorkOS Modular BoxyHQ Self-Host
SAML 2.0 / OIDC Identity Connections $18,000 (Commitment) $1,500 $0 (Open Source)
SCIM 2.0 Directory Sync Connections Included in Enterprise MSA $0 $0 (Jackson SCIM)
Enterprise MAU / Seat Surcharges Tiered in Contract $0 (Unlimited) $0 (Unlimited)
Cloud Infrastructure / Hosting Hosting $0 (SaaS Hosted) $0 (SaaS Hosted) $240 / yr
Engineered Maintenance & Security Upkeep $0 $0 ~4-8 hrs / quarter
Total 1-Year Financial Spend $18,000 $1,500 $240
Net Savings vs Auth0 Enterprise Baseline Save $16,500 (91.7%) Save $17,760 (98.7%)
app/api/auth/sso/callback/route.ts — WorkOS Zero-Lockin SSO Callback
import { WorkOS } from '@workos-inc/node';
import { NextResponse, type NextRequest } from 'next/server';

const workos = new WorkOS(process.env.WORKOS_API_KEY);
const clientId = process.env.WORKOS_CLIENT_ID!;

/**
 * Enterprise SSO Callback: Handles SAML 2.0 / OIDC assertion from Okta/Azure AD
 * Translates enterprise identity assertions into standard local JWT session.
 */
export async function GET(request: NextRequest) {
  const { searchParams } = new URL(request.url);
  const code = searchParams.get('code');

  if (!code) {
    return NextResponse.json({ error: 'Missing SSO authorization code' }, { status: 400 });
  }

  try {
    // 1. Authenticate SAML assertion with WorkOS without $20k Auth0 Enterprise MSA
    const { user, profile } = await workos.sso.getProfileAndToken({
      code,
      clientId,
    });

    // 2. Extract verified corporate claims
    const { email, firstName, lastName, organizationId, idpId } = profile;

    // 3. Upsert user in your own primary database (Supabase, Postgres, Prisma)
    const dbUser = await upsertCorporateUser({
      email,
      fullName: `${firstName} ${lastName}`,
      enterpriseTenantId: organizationId,
      ssoProviderId: idpId,
      emailVerified: true,
    });

    // 4. Issue standard HTTP-only session cookie
    const sessionToken = await createSessionToken(dbUser);
    const response = NextResponse.redirect(new URL('/dashboard', request.url));
    
    response.cookies.set('session', sessionToken, {
      httpOnly: true,
      secure: process.env.NODE_ENV === 'production',
      sameSite: 'lax',
      path: '/',
      maxAge: 60 * 60 * 24 * 7, // 7 days
    });

    return response;
  } catch (error) {
    console.error('WorkOS SSO callback error:', error);
    return NextResponse.redirect(new URL('/login?error=sso_failed', request.url));
  }
}
docker-compose.yml — Self-Hosted BoxyHQ SAML Jackson Proxy
version: '3.8'

services:
  # BoxyHQ SAML Jackson: Converts SAML 2.0 Identity assertions to OAuth 2.0 / OIDC
  # Replaces Auth0 Enterprise SSO wall with $0 license fee container proxy
  saml-jackson:
    image: boxyhq/jackson:latest
    container_name: boxyhq_jackson
    restart: unless-stopped
    ports:
      - "5225:5225"
    environment:
      - EXTERNAL_URL=https://sso.yourcompany.com
      - JACKSON_API_KEYS=prod_secret_jackson_api_key_9948
      - DB_ENGINE=postgres
      - DB_URL=postgresql://jackson_user:secure_password@postgres:5432/jackson_db?sslmode=disable
      - CLIENT_SECRET_VERIFIER=super_secret_session_verifier_token
      - PRE_LOADED_CONFIG=/etc/jackson/saml-config
      - AUDIENCE_URL=https://sso.yourcompany.com
    depends_on:
      - postgres
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5225/api/health"]
      interval: 10s
      timeout: 5s
      retries: 3

  postgres:
    image: postgres:16-alpine
    container_name: jackson_postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: jackson_user
      POSTGRES_PASSWORD: secure_password
      POSTGRES_DB: jackson_db
    volumes:
      - jackson_pgdata:/var/lib/postgresql/data

volumes:
  jackson_pgdata:
main.tf — AWS ECS Fargate Self-Hosted SAML Proxy Cluster
# Terraform AWS ECS Fargate Cluster for BoxyHQ Jackson SAML Proxy
terraform {
  required_version = ">= 1.5.0"
  required_providers {
    aws = { source = "hashicorp/aws", version = "~> 5.0" }
  }
}

resource "aws_ecs_cluster" "sso_cluster" {
  name = "enterprise-sso-proxy-cluster"
}

resource "aws_ecs_task_definition" "jackson_task" {
  family                   = "saml-jackson"
  network_mode             = "awsvpc"
  requires_compatibilities = ["FARGATE"]
  cpu                      = "512" # 0.5 vCPU
  memory                   = "1024" # 1 GB RAM

  container_definitions = jsonencode([
    {
      name      = "saml-jackson"
      image     = "boxyhq/jackson:v1.30.0"
      essential = true
      portMappings = [{ containerPort = 5225, hostPort = 5225 }]
      environment = [
        { name = "EXTERNAL_URL", value = "https://auth-sso.yourdomain.com" },
        { name = "DB_ENGINE", value = "postgres" }
      ]
      secrets = [
        { name = "DB_URL", valueFrom = aws_ssm_parameter.sso_db_url.arn },
        { name = "JACKSON_API_KEYS", valueFrom = aws_ssm_parameter.sso_api_key.arn }
      ]
      logConfiguration = {
        logDriver = "awslogs"
        options = {
          "awslogs-group"         = "/ecs/saml-jackson"
          "awslogs-region"        = "us-east-1"
          "awslogs-stream-prefix" = "sso"
        }
      }
    }
  ])
}

resource "aws_ecs_service" "jackson_service" {
  name            = "saml-jackson-service"
  cluster         = aws_ecs_cluster.sso_cluster.id
  task_definition = aws_ecs_task_definition.jackson_task.arn
  desired_count   = 2
  launch_type     = "FARGATE"

  network_configuration {
    subnets         = ["subnet-abc123", "subnet-def456"]
    security_groups = ["sg-sso-01"]
    assign_public_ip = true
  }
}
Protocol / Feature Auth0 Enterprise WorkOS BoxyHQ Jackson
SAML 2.0 Identity Providers (Okta, Azure AD, Ping) Supported (Paywalled) Supported ($125/conn) Supported (Free)
SCIM 2.0 Directory Sync & Provisioning Supported (Addon) Supported ($125/conn) Supported (Built-in)
Contract Commitment / Lock-In 1–3 Year Annual Commit Month-to-Month PayGO Zero (Open Source)
Setup Time to Production 4–8 Weeks (Sales + Legal) 1–2 Days (SDK Drop-in) 2–4 Days (Container deploy)
Admin Self-Service SSO Setup Portal Custom Domain Hosted WorkOS Admin Portal (Included) Jackson Admin UI (Included)
SAML X.509 Certificate Auto-Renewal Manual / Alerts Automated Alerts & Handling Self-Managed Webhook

The Engineering Mechanics of the "SSO Tax Wall"

In the B2B SaaS landscape, closing an enterprise contract (Fortune 500 bank, enterprise healthcare system, or global retailer) requires passing vendor InfoSec review. Ninety-five percent of these reviews mandate SAML 2.0 or OIDC single sign-on tied directly into the company’s central identity provider (Okta, Microsoft Entra ID, PingIdentity).

When an early-stage startup builds on Auth0’s self-serve tier ($23 to $240/mo), the developers assume they can simply enable SAML when the customer arrives. Then they encounter the Auth0 Enterprise Wall: SAML connections cannot be toggled on self-serve plans. Instead, clicking "Create SAML Connection" redirects the founder to a sales contact form.

The Sales Lock-In Mechanism: Auth0 sales representatives require a customized Master Services Agreement (MSA) with a strict minimum floor. In 2024–2026, standard minimums start at $15,000 to $24,000/year upfront. If your enterprise customer is paying you a $10,000/year pilot contract, upgrading Auth0 causes an immediate negative net margin on the deal.

WorkOS Modular Architecture

WorkOS decouples authentication into standalone enterprise primitives. Instead of replacing your existing user database, Clerk, or Supabase, WorkOS acts as an API gateway for enterprise identity. Each customer connection is billed at $125/month. If a customer cancels their pilot, you deactivate the connection and stop paying immediately.

Open-Source BoxyHQ Jackson

For engineering teams wanting total data sovereignty, BoxyHQ Jackson runs as a stateless Docker container. It accepts SAML assertions from Okta or Entra ID, validates signatures, decrypts assertions, and translates them into an OIDC callback compatible with standard OAuth libraries (NextAuth, Passport, Lucia).

SCIM 2.0 Real-Time Deprovisioning

SAML only handles login. When an employee is terminated, SAML does not notify your SaaS until they attempt to log in. SCIM (System for Cross-domain Identity Management) solves this by pushing webhook events (`POST /Users`, `DELETE /Users/:id`) the second IT deactivates the employee in Okta.

X.509 Certificate Expiration Outages

SAML identity providers sign assertions using public-key cryptography with certificates that expire every 1 to 3 years. When Okta rotates an X.509 certificate and your SaaS hasn't updated its metadata endpoint, enterprise logins instantly fail across every user in that company.

Frequently Asked Questions: Enterprise SSO Economics

The Auth0 SSO Wall refers to the pricing barrier where enabling SAML 2.0 or WS-Federation single sign-on (SSO) for corporate clients like Okta or Azure AD requires upgrading from standard self-serve plans ($23-$240/month) to a custom Enterprise contract. Auth0 sales reps mandate annual upfront commitments typically starting at $15,000 to $24,000/year, creating a massive barrier for early-stage B2B SaaS startups closing their first enterprise pilots.
WorkOS provides modular enterprise features with transparent, self-serve pay-as-you-go pricing. Enterprise SSO costs a flat $125 per active connection per month with zero annual minimum commitment and unlimited users per connection. If you have 2 enterprise customers using SAML, you pay $250/month ($3,000/year), saving over 80% compared to Auth0's $18,000 minimum spend.
System for Cross-domain Identity Management (SCIM) is an open HTTP protocol that allows corporate IT administrators to automatically provision and de-provision user accounts in your SaaS when an employee is hired or leaves the company. Auth0 packages SCIM strictly into enterprise tier custom add-ons, while WorkOS charges $125/month per directory connection.
Yes. Open-source solutions such as BoxyHQ Jackson (SAML Jackson) act as an intermediary OAuth 2.0 / OIDC proxy in front of SAML Identity Providers. You can deploy Jackson via Docker on an AWS ECS Fargate, Hetzner VPS, or Render instance for $15-$50/month in cloud infrastructure with zero software licensing costs.
WorkOS charges $125/connection/mo ($1,500/connection/year). If your application requires more than 14 to 18 active enterprise SAML connections, WorkOS annual spend surpasses $21,000 to $27,000, at which point a negotiated flat Auth0 Enterprise tier contract may provide predictable unit economics.
Enterprise corporate IT and InfoSec departments mandate central identity governance (SOC 2, ISO 27001, HIPAA). SAML allows IT administrators to enforce hardware MFA keys (YubiKeys), conditional IP access policies, session timeouts, and instant access revocation across all corporate software the moment an employee departs.
With WorkOS or self-hosted SAML, you simply delete or deactivate the connection and stop paying the monthly fee. With Auth0 Enterprise, you are legally locked into an annual or multi-year Master Services Agreement (MSA) with non-refundable minimum commitments regardless of customer churn.
Yes! WorkOS is protocol-agnostic. You can keep Clerk or Supabase Auth for your standard B2B/B2C email and social login flows, and route enterprise customers through WorkOS SSO callback endpoints which return standard OIDC tokens directly into your existing user sessions.
4.9 out of 5
★★★★★
Developer Community Benchmark Rating
Verified across 196 community production token & cost audits
Rate this benchmark: