---
topic: system-design
author: Crashtech Editorial
published: Nov 17, 2026 · read: 5 min
---

How SSO Lets You Skip the Login Screen on the Second App

SSO isn't one login shared across apps. It's a session with the identity provider, and a fresh token minted per app via a redirect dance.

– –

“Single sign-on” sounds like it should mean one login token that every app just accepts, which is a natural but wrong mental model — and the wrong model makes the actual mechanism (why app two never shows you a login screen) look like magic instead of a specific, traceable redirect sequence. The real mechanism is a relationship between three parties: you, the application you’re trying to use (a service provider), and a separate identity provider both of you trust.

The three parties, and what each one is actually responsible for

Service Provider (SP) the app you're using
Gmail, Slack, any SSO-integrated application. Never handles your actual credentials — only ever receives and validates a token issued by the identity provider.
Identity Provider (IdP) the one place credentials live
The single system that actually authenticates you — checks your password, enforces MFA, maintains your account. Every service provider trusts tokens this one system issues.
The browser the courier
Carries redirects and tokens between the SP and the IdP. Neither party talks to the other directly — everything routes through browser redirects.

First app: the real login happens here

  1. Access a protected resource

    You open Gmail (the service provider). Gmail’s server checks and finds you’re not logged in.

  2. Redirect to the identity provider

    Gmail redirects your browser to the company’s identity provider, carrying an authentication request.

  3. Actual login, at the IdP

    The IdP — not Gmail — shows the login form. You enter your credentials here, and only here. Gmail never sees your password.

  4. Token issued, session created

    On success, the IdP does two things: creates a secure token scoped to Gmail specifically, and creates a session for you at the IdP itself, for future reuse. The token goes back through your browser to Gmail.

  5. Validation and access

    Gmail validates the token came from the trusted IdP, and grants you access to whatever you’re authorized to see.

This is a real, full login — nothing about it is skipped. The important detail for what happens next is step 4’s second half: the IdP now has a session for you, independent of the token it just handed to Gmail.

Advertisement

Second app: same redirect dance, no login form

Now you open Slack — a different service provider, entirely unrelated to Gmail from its own point of view.

You → Slack: access protected resource
Slack → You: not logged in, redirecting to IdP
You → IdP: arrive with an auth request (same IdP as before)
IdP: checks for an existing session... finds one, still valid
IdP → You: skips the login form entirely, issues a NEW token — for Slack
You → Slack: here's your token
Slack: validates it, grants access

The login form never appears, but this isn’t because Slack somehow recognized Gmail’s token — Slack never sees Gmail’s token at all, and wouldn’t accept it if it did, since that token was scoped specifically to Gmail. What actually happened: the IdP recognized its own existing session for you, and because that session was still valid, it skipped straight to minting a fresh, Slack-specific token instead of asking you to authenticate again.

This is the whole answer to 'what does single mean in SSO'

Not one token reused everywhere — one session with the identity provider, reused every time, to mint a new token per application without re-prompting for credentials. Each app gets its own token; only the IdP session is actually shared.

Why the token gets validated, not just trusted on arrival

Every service provider independently checks any token it receives before granting access — confirming the token’s signature matches the IdP’s known public key, confirming it hasn’t expired, confirming it was actually issued for this application and not some other one. A token arriving at Slack claiming to grant access could, without validation, be forged, stale, or meant for a different app entirely — validation is what lets each service provider extend trust to a token it didn’t create itself, without that trust being blind.

Do

Scope every issued token to a specific service provider and validate signature, expiry, and intended audience on every arrival — even though the token came through a trusted redirect flow.

Don't

Treat “it came from the SSO redirect” as sufficient proof of validity on its own. The redirect flow establishes where the token should have come from; validation is the separate step that confirms it actually did, and hasn’t been tampered with or expired since.

The real security win, beyond not re-typing a password

The convenience (skip the login screen on app two, three, four) is the visible benefit, but the structural one matters more: credentials exist in exactly one place — the identity provider — instead of being duplicated, stored, and potentially mishandled by every individual application a user touches. Centralizing authentication also centralizes control: enforcing multi-factor authentication, revoking a compromised account’s access, or auditing login activity all happen once, at the IdP, instead of needing separate, inconsistent implementations in every connected app.

Takeaway

The intuitive but wrong model of SSO — “one token, shared everywhere” — makes the login-skip on app two look like a shortcut being taken. The actual model — one session with a trusted identity provider, a fresh token minted per application, every token independently validated by the app that receives it — is both more secure and more precisely the reason the experience feels seamless: nothing is being skipped or trusted blindly, the system just recognizes you’re already authenticated with the one party every app defers to, and does the token-minting work silently on your behalf.

Advertisement

Frequently asked questions

Does SSO mean all my apps share one login token?

No — each application (service provider) gets its own token, minted fresh by the identity provider for that specific app. What's actually shared is your session with the identity provider itself. When you access a second SSO-integrated app, it doesn't reuse the first app's token; it redirects you to the identity provider, which recognizes your existing IdP session and issues a brand-new token scoped to the second app, without asking you to log in again.

Why does the browser get redirected to the identity provider instead of the app checking credentials directly?

The whole point of SSO is that no individual application ever handles your actual login credentials — only the identity provider does. Redirecting the browser to the IdP for authentication means each app can trust a token issued by a party it already trusts, without ever needing to see a password, implement its own credential storage, or maintain its own user database.

What actually lets a user skip the login screen on their second SSO app?

The identity provider maintains its own session for the user, created during the first login. When the second app redirects the browser to the IdP for authentication, the IdP checks for that existing session — finds it valid — and skips straight to issuing a new token for the second app, instead of showing the login form again. The 'single' in single sign-on refers to that one IdP session, not to one token being reused everywhere.

Why does each service provider validate the token instead of just trusting it?

A token arriving at a service provider could, in principle, be forged, expired, or intended for a different application entirely. Validation (checking the token's signature against the IdP's known public key, confirming expiry, confirming it was issued for this specific app) is what lets the service provider trust a token it didn't create itself — skipping validation would mean trusting any token-shaped input, which defeats the entire security model.

What's the actual security benefit of SSO beyond user convenience?

Centralizing authentication in one identity provider means credentials exist in exactly one place instead of being duplicated (and potentially mishandled) across every application a user touches. It also centralizes control — revoking access, enforcing MFA, or auditing login activity happens once at the IdP rather than being reimplemented inconsistently by every individual app.

/* Comments */