Monday, November 16, 2026
Cover illustration for “Identity Provider Integration for Enterprise SSO in SaaS Products”
Writing for Technical FoundersIdentity Provider Integration for Enterprise SSO in SaaS Products

Identity Provider Integration for Enterprise SSO in SaaS Products

Tenant routing, not protocol choice, decides whether enterprise SSO scales.

· 9 min read

Identity provider integration for enterprise SSO is a multi-tenant data modeling and routing problem before it is a protocol choice. The architecture decides whether adding each new enterprise customer takes a change to the configuration or an engineering project. SAML and OIDC are part of the implementation, but neither can rescue a system that does not know which tenant owns a login, a user, or a deactivation event.

Why enterprise SSO is an architecture problem before it is a protocol problem

The tenant is the boundary around every identity operation. Each login, provisioning event, and deprovisioning event must resolve to exactly one tenant’s identity configuration. That obligation exists before the application contacts an identity provider or parses a response. Enterprise buyers use this identity layer to control authentication policy, MFA enforcement, user lifecycle, and audit evidence. It is an organizational control plane.

Treating the work as “add SAML, ship it” hides that boundary inside the first customer’s implementation. The first integration can look perfectly healthy. The second customer then exposes assumptions about which certificate to trust, where to send a login, and whose users a provisioning request can change.

The design therefore starts with how tenants are stored, how incoming requests find their configuration, and how callbacks select the correct validation certificate. These choices are hard to change once enterprise customers depend on them. Settle those relationships before choosing a protocol or vendor. Otherwise, the first customer’s setup quietly becomes everybody’s blueprint.

What enterprise buyers actually require and why it blocks deals when missing

Enterprise buyers see SSO as a basic security need. Its absence can block a deal regardless of product quality, and the question often arrives before a technical demo. A security review already adds weeks to the time it takes to close most enterprise deals. Finding a missing identity feature at that stage means the work to add it holds up the deal.

The buyer’s request also reaches beyond a login redirect. It includes federation with the customer’s IdP, SCIM-based user lifecycle management, exportable audit logs, and RBAC that maps to the organization. Leavers must lose access the same day. A successful SSO login proves none of that offboarding behavior. Access revocation remains a separate concern for SOC 2 review.

That scope changes the initial architecture requirement. The product needs a model that can accommodate Okta, Microsoft Entra ID, Google Workspace, PingFederate, and JumpCloud, rather than assumptions tailored to the first customer’s provider. The names change, but the tenant boundary cannot. Procurement is effectively asking whether the product can accept each customer’s identity policy without commissioning a small engineering expedition.

How multi-tenant SSO routing actually works: tenant discovery, RelayState, and the validation key problem

Tenant discovery happens before any IdP is contacted. With email-domain matching, the application takes the submitted email domain, looks it up in the tenant table, and retrieves that tenant’s IdP metadata. Alternatively, a tenant-scoped login URL puts the tenant identifier in the path or subdomain, as in app.example.com/login/acme. Enterprise IT can link directly to that address.

The outbound request then preserves that context for the callback. For SAML, the tenant ID goes into RelayState, while OIDC uses state. On return, the application uses its own request context from that value to retrieve the tenant’s stored signing certificate or JWKS endpoint. It then validates the response against that configuration. The assertion does not get to choose its own judge.

Selecting a validation key from an unvalidated assertion reverses this trust relationship. A claim that an attacker controls, such as the SAML Issuer element, can lead an unsafe implementation to use a certificate the attacker controls. That can bypass authentication entirely. Tenant resolution and key selection must therefore come from the application’s tenant configuration.

The configuration record makes that rule concrete. SAML needs the IdP entity ID, SSO URL, signing certificate in PEM format, and optional attribute mappings. OIDC needs the issuer URL, client ID, client secret, and JWKS endpoint or discovery URL. Both have a tenant ID foreign key, a protocol type flag, and an active or inactive status. These shared fields let tenant routing work the same way while SAML and OIDC each use their own validation fields.

Why supporting both SAML and OIDC is a data modeling requirement, not a feature flag

Customers often determine the protocol. SAML 2.0 uses signed XML assertions and remains an explicit requirement in enterprise workforce RFPs. OIDC uses signed JWTs over OAuth 2.0 and is simpler to validate. That technical preference does not override a customer’s security requirements. With a SAML-only or OIDC-only model, a customer’s buying decision can force the team to migrate its own system.

Zoom shifted its primary federation protocol to OIDC for new SaaS-to-SaaS integrations in 2025 while retaining SAML for a large existing enterprise base. Its coexistence model differentiates configurations with a protocol type flag. Microsoft Entra ID illustrates another constraint on customer choices, namely licensing. Its free tier supports OIDC sign-in for users with a Microsoft 365 license and SAML federation to third-party SaaS applications. Paid P1 features include Conditional Access, group-based assignment, and SAML token encryption, so the relevant distinction is the surrounding controls.

A tenant SSO configuration table stores saml or oidc with the protocol-specific fields, rather than splitting the model into two tables that require joining. The service provider endpoint is shared across tenants, and the tenant record determines the protocol after identification. The admin portal exposes both configuration paths. Deferring OIDC in a SAML-only design can instead force changes to live callback, session, and JIT provisioning logic, where “add it later” stops sounding inexpensive.

JIT provisioning covers onboarding; SCIM is required for the offboarding that auditors actually check

JIT provisioning creates an account at first SSO login. It uses assertion attributes such as name, email, and role mappings, then gives the user access without a separate pre-provisioning step. That solves onboarding. It has no corresponding event when an employee is disabled or deleted in the IdP.

As a result, the SaaS account, active sessions, profile data, and data footprints can remain after the IdP entry disappears. These are zombie accounts without the warning music from the movies. Blocking a future login is not the same as revoking existing access. SOC 2 access revocation controls in CC6 focus attention on that gap, which JIT alone cannot close.

SCIM 2.0 supplies the missing lifecycle events. The customer’s IdP pushes create, update, and deactivate requests to /scim/v2/Users, with deactivation triggering immediate access revocation. But two provisioning paths introduce another risk. If JIT and SCIM identify the same person differently, they can create parallel records with conflicting permissions, duplicate data footprints, and awkward audit trails.

The user record stores the IdP’s subject ID or externalId from the SCIM payload, and both paths check that shared identifier before creating anything. Keycloak promoted its SCIM API from preview to supported in release 26.8.0 on October 1, 2026, and included SCIM permission fixes in that release. After tenant routing, SCIM endpoint design is the next architectural decision.

The self-service admin portal as a forcing function for scalable enterprise onboarding

The admin portal is the operating surface of the tenant configuration model. Without it, customers email metadata, someone enters it, and engineering or support arranges tests with the customer’s IT team. That process takes days and scales poorly.

SAML setup accepts metadata XML or manual entry of the entity ID, SSO URL, and certificate, while OIDC setup accepts a discovery URL or manual client configuration. Attribute mapping lets IT administrators match non-standard names for first name, last name, and role to fields in the application. A test-connection flow checks that a login works before production traffic switches.

The portal is also a security boundary. An administrator must be able to view and change only their own tenant’s configuration, and domain verification prevents one tenant from claiming another’s email domain. A configurable fallback method, such as a magic link or time-limited password, keeps an IdP outage from causing complete lockout. WorkOS offers an embeddable, white-labeled Admin Portal for customer-managed SSO and SCIM setup.

Build vs. buy: what the engineering cost argument actually looks like for a multi-tenant SSO stack

An in-house build is a legitimate architectural choice. Its scope, however, includes tenant routing, both protocols, SCIM with consistent identifiers, certificate rotation, an admin portal, and ongoing security maintenance. Estimating only the login integration leaves most of the system outside the budget. Those omitted parts tend to return as support work, which is a remarkably inconvenient way to discover requirements.

Self-hosting platforms such as Keycloak or Ory can work for teams that have the capacity to run the infrastructure and need control of the data-plane. It also answers concerns about vendor lock-in, pricing curves, and where the authentication control plane sits relative to the compliance boundary. The operational work stays internal. Upgrades, security patches, performance tuning, and high-availability configuration all belong in the cost comparison as “maintenance.

WorkOS and SSOJet provide purpose-built B2B SSO layers, while Auth0, Frontegg, Descope, Stytch, and FusionAuth offer full CIAM platforms. The evaluation needs to examine tenant isolation and how much integration work the application retains. SCIM maturity deserves its own test. JIT and SCIM push provisioning must converge on the same user record, regardless of how polished the login demonstration looks.

Pricing introduces a separate architectural trade-off. Per-connection pricing is based on how many enterprise customers there are, while pricing based on monthly active users counts the users inside those connections and can rise when customers have large directories. CISA has explicitly told buyers to ask for standards-based SSO at no additional cost and has linked the SSO tax to weaker security at smaller companies. A defensible product pricing model gates expensive operational features, including SCIM at scale, custom roles, and extended log retention, while keeping the password-replacement baseline available at no additional cost. This is a security decision as well as a packaging decision.

A managed provider can handle protocol implementation and the admin portal, but the SaaS team still owns the tenant data model, identifier consistency, attribute mapping schema, and RBAC logic that translates IdP roles into application permissions. Those are application decisions. The team should therefore compare the cost of building and running the whole system with the cost of the provider’s service plus the architecture it must still own.

The emerging scope expansion: non-human identities and agent credentials in the same tenant model

API integrations, automation accounts, and AI agents bring the same identity problem to things other than people. Their credentials need tenant isolation, stable identifiers, and a create, update, and deactivate lifecycle. Human SSO does not control that access on its own. Broad default trust can remain when role mapping, token scope, and tenant context are not controlled for each identity type.

There is no universal standard for non-human identity lifecycle across SaaS tenants. SCIM’s subject model is designed for human users, so service accounts and agent identities require explicit schema decisions rather than a claim that SCIM already solves everything. Practitioners are combining SSO and SCIM with policy-as-code, approval workflows, and usage-based token expiry. Service account entries have their own scope and expiry fields and must be deactivated with the same care as human users. The machinery is developing.

That uncertainty makes the initial schema more consequential. A human-only model leaves a migration waiting for the first customer who asks where API credentials are managed. Make identity type an explicit field in the tenant configuration schema from the start. Then the next kind of identity has a defined place in the system, rather than another exception held together by a support ticket.

More in Connector Ecosystem