
One of the first decisions you must make when architecting a new B2B application? How you’re going to allow users to authenticate.
You have two choices: the universal login page or the organization-specific login page. We’ll make the distinction clear in a moment, but for now, know that the path you choose here has significant downstream effects on the entire lifecycle of your B2B application, and in ways far more significant than designing and developing a login page that looks good. Notably, three personas are most affected with the choice you make:
This decision also contributes greatly to the user experience during login.
Conveniently, two popular applications—Notion and Slack—have made different choices for end-user authentication flows. Their ubiquity makes them ideal for identifying how they implemented differing flows, tracing the pros and cons for each affected persona, and ultimately helping you create the best authentication paradigm for your application.
Before diving too deeply into authentication nuances, let’s clarify our definitions.
With a universal login page, the application identifies which organization the end user belongs to. In contrast, with an organization-specific page, the end user shares the organization as input to the application before they can be authenticated.
With Notion, you start authentication by loading the universal login page at notion.so/login. You give your work email address, which Notion uses to identify which organization you belong to based on the domain name. If your email is celina@foocorp.com, Notion assumes you’re part of the organization associated with foocorp.com.

Notion uses that information to provide you with the next best step for the authentication flow, which might be entering a password, using SSO, receiving a magic link, or any auth setting configured by your IT admin.
In the case of Slack’s authentication experience, as an end user, you must navigate to the Slack’s organization-specific login page at a specific URL, like foocorp.slack.com. In this case, you’ve already specified which organization you belong to (Foocorp) through the subdomain, and Slack uses that information to show you the appropriate authentication flow.

In both cases, once the application identifies the end-user’s organization, it honors their authentication settings, including SSO, identity provider, multi-factor authentication (MFA), password policy, and so on.
The user experience (UX) around honoring those settings can still vary between applications. Notion’s universal login page, for example, separates the email and password fields so it can perform the home realm discovery (that’s discovering the tenant) and honor auth settings.
Note that Dropbox hides the password field if the email address entered matches a tenant with enterprise authentication enabled.
Freshworks takes yet another approach, using home realm discovery to ascertain your tenant and redirecting your browser to an organization-specific login page. Again, these differences might seem small, but the impact is outsized by a few orders of magnitude by the resulting choices around implementation and infrastructure.
A tangential factor to keep in mind is IdP vs. SP-initiated login. Explore the concept in this blog.
Tenancy is the architectural decision to isolate the authentication policies, settings, users, and data between each organization registered with an application. Multi-tenant architecture is an essential ingredient for the authentication and security of a SaaS app, ensuring a user of organization Foorcorp can never read data belonging to organization Barcorp.
Home realm discovery (HRD) is the process by which a application identifies which tenant a user belongs to from the login page. Because every application uses a multi-tenant architecture, HRD is also necessary, as there could be a hundred Celina users, each belonging to a different organization and stored inside a different tenant. HRD requires an identifier, which applications collect in a few standard ways:
If we map this idea to the universal and organization-specific login pages concept from before, we can clarify our definitions even more.
Once the application completes HRD and maps the end user’s identifier to a tenant, it can honor those authentication settings and allow them to finish logging in using approved methods. Now that you understand the two possible authentication flows for a application, and how each works alongside your required multi-tenant architecture, we can explore those big implications.
Pros
Cons
Pros
Cons
Pros
Cons
Pros
Cons
Pros
Cons
Pros
Cons
Frankly, there is no direct answer. The best solution is based on your customers and admins experience in your application. As you’re making other architectural and technical decisions, such as which JavaScript UI framework to choose, whether to build a monolith or many microservices, or which cloud provider gives you the most startup credits, you should take time to weigh the user experience for each persona in light of your long-term go-to-market (GTM) strategy.
Generally, if you’re appealing to the end-user experience, universal login pages are most familiar to the widest range of users. If you need to offer the customer IT administrator complete flexibility, or are selling to enterprise customers who expect a completely white-labeled solution, then organization-specific pages are a great fit.
What type of login page did Scalekit pick? When we reach general availability, we’ll use a universal login page, where our application performs HRD using the user’s work email as the identifier.
We opted for the universal login page to ensure our users always have the simplest possible experience logging in. We don’t want situations where users have lost their accounts simply because they forgot which subdomain they’re supposed to navigate to. We know that comes at a higher technical cost to us around HRD, but it’s a sacrifice we’re willing to make for the most seamless end-user experience.
The other decision you must make early on is how you’ll build the authentication integration itself. You can go it alone and build a SAML implementation for ultimate control at the cost of complexity and many developer hours, or you can partner with a platform like Scalekit to get your B2B application enterprise-ready in days, not weeks or months.
Either way, ensure your choice lets you also pick the login page that works best for your customers—once you’ve started developing and deploying infrastructure, you can’t take your choice back.
Universal login pages offer a single entry point like notion.so where the application identifies the user tenant through home realm discovery. This usually involves checking the email domain or a specific identifier. In contrast organization-specific login pages require users to navigate to a unique subdomain such as foocorp.slack.com. Here the user performs the discovery by providing the organization name upfront. While universal login simplifies the user experience by providing one well known URL organization-specific pages allow IT administrators to customize the interface and enforce specific security policies for their unique enterprise environment.
Home realm discovery is the critical architectural process of identifying which tenant a user belongs to during login. Because B2B applications utilize multi-tenant architectures to isolate data and policies the system must map a user identifier to a specific organization. This discovery typically uses the domain name from a work email address or a unique organization ID. Once the tenant is identified the application can honor specific authentication settings like SAML SSO or multi-factor authentication. Implementing robust discovery is essential for universal login patterns to ensure users are routed to the correct security perimeter and data residency region.
Implementing universal login simplifies the front end since developers only manage one interface and user journey. However it places a significant burden on the backend to handle complex home realm discovery logic. Engineers must build systems to detect tenants from email domains or identifiers and handle potential overlaps. Additionally if customers require strict data residency the backend must manage network level redirections to ensure authentication happens within the correct geographical region. While it provides a seamless experience for end users it requires more sophisticated infrastructure and logic compared to simple organization-specific subdomains.
Organization-specific login pages offer enterprise IT administrators high levels of control and customization that universal pages often lack. Administrators can white-label the login experience with corporate branding making the product feel like an internal tool. They can also restrict authentication methods to only approved identity providers or enforce custom legal disclaimers during the login flow. This granularity ensures that the authentication experience aligns perfectly with internal security compliance and corporate identity standards. Although it requires educating employees to use a specific URL the benefits of control and branding often outweigh the minor inconvenience.
As B2B ecosystems evolve toward AI agents and machine-to-machine communication authentication must move beyond manual login pages. Identity providers now utilize machine-to-machine and app-to-app protocols to secure these interactions. This involves using client credentials or specialized tokens to ensure that AI agents can verify their identity without human intervention. Technical architects must design systems that handle both human-centric universal login and automated agent authentication. By integrating these capabilities into a unified identity layer platforms like Scalekit help developers manage complex authorization across both humans and autonomous agents while maintaining strict tenant isolation and security boundaries.
Data residency requirements often dictate where user authentication and data storage occur. With organization-specific login pages mapping DNS records to regional cloud resources is straightforward since the subdomain directly indicates the tenant location. For universal login the application must perform home realm discovery before it knows where the user data resides. This requires a global routing layer that can identify the tenant and then redirect the authentication request to the appropriate regional instance. Architects must decide if they want to manage this complexity centrally or distribute it across subdomains to satisfy strict legal and compliance mandates.
There is no universal answer because the best experience depends on your target market. Universal login pages are generally preferred for ease of use because users only need to remember one main URL. This reduces friction and prevents account abandonment caused by forgotten subdomains. However for enterprise users an organization-specific page can provide a more tailored and secure environment that reflects their own corporate identity. Architects should weigh the simplicity of a single entry point against the need for deep customization and specific security enforcement required by large scale business customers during the initial design phase.
Once a login page identifies the tenant through discovery or a subdomain it must immediately honor that organization's security configuration. This includes triggering single sign-on flows with identity providers like Okta or Azure AD and enforcing multi-factor authentication if required. Some applications like Dropbox even hide the password field if the detected email domain belongs to an enterprise tenant with SSO enabled. By dynamically adjusting the login flow based on tenant settings the application ensures that every user follows the exact security path mandated by their IT administrator without requiring manual configuration from the user.
Building a custom multi-tenant authentication system with support for both universal and organization-specific login is a massive undertaking. It involves managing complex SAML integrations home realm discovery and tenant isolation logic which can take months of engineering effort. Using a dedicated provider like Scalekit allows developers to become enterprise-ready in days by abstracting these complexities. Architects gain access to pre-built infrastructure for SSO directory sync and flexible login experiences. This enables engineering teams to focus on their core product features while ensuring the authentication layer is secure scalable and capable of meeting the demands of large enterprise customers.