Single Sign-On Integration: Architecture and Rollout Guide

Engineer configuring a single sign-on integration

Single sign-on integration connects your applications to one central identity provider (IdP), so people authenticate once and reach every connected system without signing in again. The login screen is the easy part. The real work is the trust between systems, the protocol you choose for each application, and the legacy estate that cannot speak modern standards. This guide covers all three for CTOs, integration managers and executives who own the outcome.

Polarising
polarising.com
Connect Identity Across Complex Systems
Polarising integrates AI and enterprise systems, bringing engineering experience to the complex application and legacy challenges behind SSO rollouts.

Explore AI-assisted legacy analysis

Key Takeaways

  • SSO is an architectural pattern, not a single product. It rests on a trust relationship between one identity provider and many service providers, expressed through signed assertions or tokens.
  • Choose the protocol per application: SAML for traditional enterprise web apps, OpenID Connect for modern web, mobile and API-driven applications.
  • Most SSO projects stall on legacy applications and on inconsistent user data, not on the IdP itself. An application inventory comes before any configuration.
  • Treat SSO as an enforcement point inside a Zero Trust design, wired to security monitoring, rather than as a convenience feature.
  • Integration middleware is often the practical bridge between a modern IdP and systems that cannot federate natively.

Table of Contents

What single sign-on integration actually involves

SSO lets users authenticate once with a centralised IdP and then access multiple applications without re-entering credentials. Integration is the work of making each application trust that IdP: registering it, agreeing on the identifiers and attributes exchanged, mapping users, and testing failure paths.

For a CEO, the value is fewer password-reset costs, faster onboarding and offboarding, and a single place to enforce access policy. For a CTO or integration manager, the question is how many applications can be connected cleanly, how many need a workaround, and who owns the result when something breaks at 8 a.m. on a Monday.

How the authentication flow works

The sequence is the same in spirit whichever protocol you use. Per Auth0’s description of the flow:

  1. A user opens a protected application (the service provider, or SP).
  2. The SP redirects the browser to the IdP.
  3. The IdP authenticates the user and establishes a session.
  4. The IdP returns a signed SAML assertion or, with OpenID Connect, an authorisation code that is exchanged for an ID token and access token.
  5. The SP validates the signature, expiry, not-before time, issuer and audience, then creates its own local session.
  6. When the user opens a second application that trusts the same IdP, the IdP can issue a new application-specific token without asking for credentials again.

Microsoft describes the same pattern in four steps for Entra ID: the user requests access, the app sends them to the IdP, the IdP verifies credentials, and the app grants access. The application never handles the user’s raw password. That single property is the main security gain.

SSO architecture: the components and the trust between them

An SSO architecture separates two roles. Identity providers store and serve identity profiles and handle authentication, while service providers offer the services and handle authorisation. A “circle of trust” groups at least one IdP and one SP that agree to share authentication information through assertions about authenticated users.

In practice you will manage five building blocks:

Component Role Typical enterprise concern
Users Employees, partners, customers Different populations often need different policies
Identity provider Central authentication and trust anchor Availability, resilience, MFA policy
Service providers Applications that rely on the IdP Protocol support, attribute requirements
Protocols SAML, OIDC, OAuth 2.0, Kerberos Fit per application, not one-size-fits-all
Directory Credentials, roles, attributes Data quality and ownership

The trust itself usually rests on a certificate. Oracle’s deployment documentation notes that a service provider and an identity provider must be set up within a circle of trust before SSO works between them. Certificate expiry is therefore an operational risk, and someone must own its renewal.

Where LDAP and MFA fit

Readers often ask how SSO differs from LDAP. LDAP is a directory protocol, a way to query and authenticate against stored identities. SSO is the user experience and pattern built on top, and an LDAP or Active Directory store is frequently the authoritative source behind the IdP. MFA is a separate control: it strengthens how the IdP verifies a user, and SSO means you enforce it once rather than application by application.

Roles of LDAP, SSO, and MFA in access

Choosing a protocol: SAML, OpenID Connect, OAuth 2.0 and Kerberos

Microsoft’s guidance is that SAML 2.0 suits traditional web apps needing detailed user attributes, while OIDC suits modern web apps, mobile apps and APIs that need both authentication and authorisation. That gives a workable default.

  • SAML 2.0: XML-based, mature, and supported by most enterprise SaaS and older internal portals. Choose it where the application only speaks SAML.
  • OpenID Connect: an identity layer on OAuth 2.0 using JSON tokens. Choose it for new builds, single-page applications, mobile apps and API-led architectures.
  • OAuth 2.0: delegated access, not login on its own. Use it to authorise API calls, and pair it with OIDC when you need to know who the user is. Our note on OpenID Connect versus OAuth 2.0 goes deeper.
  • Kerberos: ticket-based authentication, suited to internal domains where network trust is the governing constraint.

The common question of whether OIDC is replacing SAML has a practical answer: for new applications, OIDC is usually the first choice, but SAML remains embedded across enterprise estates and will be there for years. Plan for both.

An implementation approach that survives legacy estates

The US federal Enterprise SSO Playbook (version 1.3, March 2026) is written for government agencies, but its sequence applies to any large organisation: secure enterprise support; inventory and analyse applications; review the architecture and connect user data and security monitoring; configure, test and release integrations while enforcing phishing-resistant MFA for modern and legacy apps; then extend federation to partners.

Here is how that looks when you are accountable for delivery.

1. Inventory every application

List each application with its owner, user population, authentication method and protocol support. You will find three groups: applications that support SAML or OIDC natively, those that only support LDAP or local accounts, and those that support nothing. Each group needs a different plan, and the third is where budgets are lost.

2. Fix identity data first

SSO exposes poor data. Duplicate accounts, inconsistent email formats and stale leavers all surface as failed logins. Agree which directory is authoritative, which attributes are passed to each application, and who may change them. Where attributes about people cross organisational boundaries, treat release decisions as a privacy question as well as a technical one.

3. Design for availability

Once everything depends on one IdP, its outage is your outage. Decide on resilience, break-glass administrator access and what happens to sessions during a failure before go-live, not after.

4. Integrate in waves

Start with a few high-use, low-risk applications to prove the pattern, then move to critical systems, then the awkward ones. Each wave should have a rollback route.

5. Connect to monitoring

Feed authentication events into your security tooling so unusual sign-ins are visible. If you need help preparing the service and joining it to monitoring, advanced security services are one route for smaller owner-led organisations. At enterprise scale, this usually sits with your own security operations team and delivery partner.

Making legacy and non-standard applications part of SSO

This is where most programmes need engineering rather than configuration. Typical patterns include:

  • A gateway or proxy in front of an older web application that injects identity headers after the IdP has authenticated the user.
  • A token-translation layer in integration middleware, so an application expecting one format can accept another.
  • API-level propagation, where the identity established at login travels with each downstream call, so back-end services can authorise on behalf of the user.
  • Modernising or replacing the application when the other options cost more than the change. Our guide to cloud-native architecture without a full rewrite covers when that trade is worth making.

Integration platforms matter here. At Polarising we work with Boomi, MuleSoft, TIBCO and Solace, and we use their API and event capabilities to carry identity context between systems: authenticating at the edge, validating tokens on APIs, and passing identity claims along event streams so that downstream consumers know who initiated an action. The platform choice usually follows what your estate already runs, which is why we describe our approach on the integration platforms page. Sound API governance keeps this from slowing delivery, as we explain in API governance without blocking delivery.

Security and governance controls to build in from the start

The IDManagement playbook frames SSO as a key enforcement point in a Zero Trust architecture, with continuous evaluation of identity risk through integration with SIEM or CDM tools, rather than a standalone convenience. That is a useful test for your design: if SSO does not feed policy decisions and monitoring, you have centralised logins but not control.

For your steering group, a short checklist:

  • Phishing-resistant MFA enforced at the IdP for privileged and remote access.
  • Signed assertions and tokens validated by every application, including audience and expiry.
  • Certificate and secret rotation owned, scheduled and monitored. See our note on secrets management for UK teams.
  • Joiner, mover and leaver processes that remove access in the directory and therefore everywhere.
  • Audit logs retained and reviewed, with named accountability.

Our wider thinking on this is in Zero Trust architecture: principles and implementation.

Common SSO integration problems and how to diagnose them

Most failures are mismatches between two configurations that should agree. Microsoft’s SAML debugging guide tells administrators to check that the request destination matches the IdP’s single sign-on URL, that the issuer matches the identifier configured for the application, and that the assertion consumer service URL is where the application expects the token. It also suggests capturing the SAML request and response with a browser tool to see what was actually sent.

Splunk’s troubleshooting documentation lists similar causes: entity ID or ACS URL pointing at the wrong place, an entity ID that differs between IdP and service provider, and claim names with the wrong letter case.

A quick triage order that saves time:

  1. Compare identifiers and URLs on both sides, character for character.
  2. Check certificate validity and the clock difference between systems.
  3. Inspect the claims actually sent against those the application requires.
  4. Confirm the user exists and is mapped in the target application.

Our perspective on SSO as an integration programme

We see SSO projects succeed or fail on integration, not on the identity provider. Choosing a platform takes weeks. Connecting forty applications, three directories and a handful of systems built before federation existed takes engineering judgement.

Our teams are senior and nearshore, based in the UK and Portugal, and we have more than 20 years of engineering experience in complex, legacy-heavy estates. That matters on SSO because the hard cases are the ones generic teams avoid: the old portal with its own user table, the batch system that needs a service identity, the event platform that has to carry who did what.

Our view is that identity should be designed into the integration layer from the start, with governance and accountability built in rather than added at audit time. We use Boomi, MuleSoft, TIBCO and Solace where they fit your estate, and we make identity part of how APIs and events are secured, not a separate project beside them.

The outcome to aim for is simple to state: one trusted identity, enforced consistently, visible to security, and resilient enough that the business never notices it.

Polarising Team

Where Polarising can help

If your SSO programme includes legacy systems, several directories or a mix of API and event platforms, our enterprise integration services cover the engineering between the identity provider and the applications that must trust it. We work in regulated, high-volume environments across finance, healthcare, telecommunications and logistics, and we can scale team size and seniority as the programme moves through its waves.

Polarising

If you are modernising applications at the same time, our custom application development team can build SSO-ready services from day one.

FAQ

What is a single sign-on architecture?

It is a design in which one identity provider authenticates users and many service providers trust it through signed assertions or tokens. The parties are grouped in a circle of trust, usually backed by exchanged certificates. A directory stores the identities behind the IdP.

What is the difference between SSO and MFA?

SSO removes repeated logins by letting one authentication serve many applications. MFA adds further proof of identity, such as a second factor, during that authentication. They work best together: with SSO you enforce MFA once at the IdP rather than in every application.

What is replacing SAML?

Nothing has fully replaced it. OpenID Connect is the usual choice for new web, mobile and API-driven applications, but SAML remains widely used in enterprise software. Most estates run both for years, so plan to support each where it fits.

How long does an SSO integration take?

The identity provider can be configured quickly, but the programme length depends on how many applications you have and how many lack native support. Legacy systems and poor directory data are what extend timelines, so an early application inventory gives the most reliable estimate.

Sources

Content strategy and optimisation for Google and AI-powered search platforms by Velveteen SaaS — specialists in online visibility and customer acquisition.