Concepts · 07
Sign-in and access
Not everyone in a company needs to build workflows, manage people, or configure agents. Many people only need to use a few apps their team built for them. Console access lets you decide, per person and per company, whether someone works in the platform's management interface or uses only the apps shared with them. The access portal and the company's start URL decide where those people arrive and where they sign in.
The console
The console is the platform's management interface: the pages where people build workflows and worksheets, manage files, configure agents and automations, author apps, and administer users, roles, and permissions. Everything a person sees in the console is still governed by their permissions; console access only decides whether they may use the console at all.
An app is not part of the console. When someone opens an app, it runs in its own view, and every action it takes runs as that person, checked against their own permissions. That separation is what makes app-only access possible.
Console access
Console access is a setting on each company membership. It is on by default for every member, including existing ones. Switching it off means: this person uses only the apps shared with them. Because it belongs to the membership, the same person can have console access in one company and be app-only in another.
Switching console access off changes nothing else about the membership. The person:
- still appears to everyone in IAM → Users, like any other member;
- can still receive roles, teams, service access, and permission grants, and those keep deciding what they may do;
- keeps their account, password, multi-factor authentication, and other companies.
Three guards keep a company manageable:
- nobody can change their own console access;
- only a member who holds the system Owner role can change the console access of another system owner;
- a company always keeps at least one system owner who has console access. A custom role named Owner does not count. Switching off the last system owner is refused, and so is any other change that would leave the company without one: removing that owner from the company, removing their owner role, or giving them another base role.
Every change is recorded in the company's IAM activity as iam.member.console_access_changed.
Console access applies only to people. API keys, agents, automations, workflows, and other machine principals are not company members in this sense and are never affected by it. That includes API keys and agents the member created: they keep working after the member's console access is switched off. To cut that access too, delete those API keys and deactivate those agents.
What an app-only member can do
A member without console access can:
- sign in and manage their own account (profile, password, MFA, sessions);
- open the company's apps start page and see the apps they may use;
- open any app they have been granted use of (the User preset on the app's security page), and use it fully: every action the app takes on their behalf works, subject to their normal permissions;
- preview files from inside an app; previews open in the platform's simple file viewer.
They can open and use the apps shared with them, and nothing else. They cannot open console pages for that company (the platform sends them to the apps start page instead), and they cannot use their own sign-in to call the platform's APIs for that company directly, beyond listing and opening the apps they may use. That includes an app's source, versions, and builds, even for an app they may use. The app summary they can read leaves out the source storage, the draft build, and how widely the app is shared; it still says whether a published version exists, so the start page can open it. Such a call for the source, versions, or builds is refused, usually with HTTP 403 and the error code console_access_denied, or answered as if they had no access (for example, an empty list). A sign-in that has not selected a company yet is a different refusal: HTTP 401 company_token_required. Select the company and retry. That token is valid; it is not a bad credential.
Enforced by the platform
Console access is enforced by the platform's servers, not by hiding pages in the interface. Platform requests from an app-only member for company data are refused with console_access_denied, or answered as if they had no access (for example, an empty list), whether they come from a browser, a script, or the SDK; a few personal settings stay available. Requests that an app makes on the member's behalf are recognized as coming from that app and go through the normal permission checks.
Two consequences follow. An app-only member never gains a back door into the console by calling the API by hand. And an app never gains more than its user: the member's permissions, the app's tool policies, and every other gate still decide each call, exactly as they do for a member with console access.
Switching it off takes effect without a new sign-in
The person does not need to sign out. Their next direct requests are refused, and the console sends them to the apps start page as soon as one of its requests is refused. When console access is switched back on, reloading the page, or signing out and in again, makes every console page available.
The apps start page
Every company has an apps start page at /apps/{company_slug}. It is built into the platform, needs no setup, and works for every member, with or without console access. It shows:
- the company's logo above the heading “Your apps” (the platform logo when the company has not uploaded one; see Company icon and logo);
- the published apps the signed-in person may use, and nothing else (apps that were never published or are archived are not listed); each one opens the app's published version;
- “No apps have been shared with you yet” when there are none, so an administrator knows to grant use of an app;
- a company switcher when the person belongs to several companies;
- sign out;
- a link to the console, shown only to people who have console access.
The list follows permissions: granting someone use of an app adds it to their start page, and revoking it removes it. Each app opens at its own address, which always shows the currently published version, so the page never needs updating when an app is republished. See App address.
An app's address, /apps/{company_slug}/{app_slug}, behaves like the start URL: signed out, it shows the company's sign-in page and then opens the app. For an app marked as a portal, that sign-in page is the company's own, designed in the app. People with console access reach the start page from the Your apps link in the console sidebar, so they can use a company's apps the same way their app-only colleagues do.
Start URL
The address of the apps start page, /apps/{company_slug} on the platform's address (for example https://platform.ergondata.ai/apps/acme-corp), is the company's start URL. It is a single link people can bookmark, and it does two things:
- Signed in, it shows the company's apps start page, described above. Someone who already has a session does not see a sign-in form there, unless their session has not signed in at this company's start URL and needs to (see Signing in to several organizations).
- Signed out, it shows the company's own sign-in page: the company's logo (or its icon and name, or the platform logo), and the same sign-in methods as the platform login: email and password, a multi-factor code when the account or the company requires one, and Google or Microsoft single sign-on where they are offered. It links to password reset. It does not offer account creation; people join a company by invitation.
Signing in at the start URL signs the person in to that company and opens its apps start page. People with console access there continue to the console with Open console. The session opens that company only: the person's other companies open after they sign in at those companies' start URLs or at the platform login, as Signing in to several organizations describes. The start URL grants nothing by itself: what the person may open is still decided by their membership, console access, and permissions.
The start URL always shows this built-in sign-in, even when the company has portals. A sign-in at a portal counts as a sign-in at the start URL.
A start URL for a company that does not exist shows the platform's generic sign-in page, with no company name. Because the start URL is a stable link, it is what you add to your organization's intranet or to the app list of your own single sign-on provider; see Force sign-in through your start URL.
Access portal
Access portal decides where a person lands in a company after signing in, and when they switch to that company. The organization sets it for everyone in IAM → Sign-in, and each membership inherits it unless it is overridden next to console access in the Access section of IAM → Users → member → Overview. The values are:
- Default. The person lands by console access: in the console when they have it, on the apps start page when they do not. This is the behavior every member had before the setting existed.
- Apps start page. The person lands on the company's apps start page even when they have console access. The console stays reachable from there through Open console, and from the Your apps link in the console sidebar back again.
- A portal App. The person lands in one of the company's portal Apps, listed by title under Portal apps. When that App can't be opened for them (it is no longer a portal, is unpublished or deleted, or they may not use it), they land on the apps start page instead.
The access portal is not a permission and takes nothing away: a member with console access keeps it, and a member without console access lands on the apps start page whatever this setting says. Like console access, it belongs to the membership, so the same person can land on the start page in one company and in the console in another.
A member's own setting is Inherit until someone overrides it; the option shows the organization's value, for example “Inherit (Apps start page)”. Overriding with Default, Apps start page or a portal App keeps that value for the member whatever the organization later chooses, and choosing Inherit again follows the organization once more, so two members of one company can land in different portal Apps. Every organization starts at Default, so nothing changes until someone picks another value. In the API the organization's field is access_portal on the company (null for Default, "platform_default" for the apps start page, "app:{app_id}" for a portal App, with the App id in lower case); on a membership null inherits, "default" overrides with Default, and the member list also returns effective_access_portal, the value that applies.
Only an App that people can sign in at right now can be chosen: one of the company's Apps, marked as its portal, with a published version that has an auth module. Anything else is refused with HTTP 400 access_portal_app_unavailable (and HTTP 503 when the platform can't check the App at that moment). The check happens when the value is set. An App that later stops being a portal keeps its place in the setting, shown as “Unavailable app”, and people land on the apps start page until it is a portal again or someone picks another value.
The access portal is also the place the next setting points at: choosing one is what makes “Require sign-in through access portal” available.
Require sign-in through access portal
Require sign-in through access portal works the same way: the organization switches it on or off in IAM → Sign-in (off to start with), and each membership inherits it or overrides it with On or Off. When it applies, the person must sign in for that company at the company's start URL or at one of its portal Apps. It needs an access portal other than Default: the organization's switch stays disabled while the organization's access portal is Default, a member's On needs Apps start page or a portal App as their own or inherited access portal, and the API refuses it otherwise with access_portal_required. A member whose access portal is Default is never required to sign in for the company, even when the organization requires it. To require it for everyone except a few people, switch it on for the organization and set those people to Off.
What the person sees when they sign in anywhere else, such as the platform login:
- their password, MFA, or single sign-on succeeds as usual, but the platform does not open that company;
- when they open that company (or it is their only one), the browser goes to their access portal: the company's start URL, which shows “{Company} asks you to sign in here” above the company's sign-in form, with a way to sign out or go back to their other organizations, or the address of their portal App, which shows the App's own sign-in;
- signing in there opens the company normally, with password, MFA when it is required, or Google and Microsoft single sign-on started from that page.
A client that selects the company through the API gets HTTP 403 with the error code portal_sign_in_required and a portal_url to send the person to: the start URL, or the portal App's address /apps/{company_slug}/{app_id} when their access portal is a portal App. If that App has stopped being a portal, its address shows the company's built-in sign-in instead. The rule is worked out for each membership, from its own setting or the organization's, and never for a person across companies:
- the same person's other companies are unaffected; they can keep signing in at the platform login for those, and switching from them to this company sends them to its start URL to sign in;
- it applies from the person's next sign-in or the next time they open the company (reloading the page or switching company counts); a session that has signed in at the start URL keeps satisfying it until it ends;
- console access is separate: it still decides what the person may use once inside. Both can be on at once.
Every sign-in at a start URL is recorded in the person's access history (and in the member's access history for that company) as a sign-in at the company's start URL, shown with Access portal next to the sign-in method, so administrators can see where people signed in. A sign-in at a portal App is shown with Through {App} instead, naming the App; only that company's history names it.
A routing rule, not an extra factor
Requiring the start URL steers where people sign in and records it. It does not add a factor or change how people prove who they are: the same account and credentials work at the start URL and at the platform login. To strengthen sign-in itself, require multi-factor authentication for the company.
Signing in to several organizations
A person who belongs to several companies has one account. Which of those companies a session opens depends on where it signed in:
- At the platform login. The session lists every company the person belongs to, and each one opens right away, except a company that requires this person to sign in through its access portal, or whose sign-in rules don't accept how they signed in. Picking that company shows its sign-in page, and signing in there opens it.
- At a company's start URL. The session opens that company. The person's other companies are not listed, so with one company there is no organization picker.
A session keeps every place it has signed in at. Signing in again in the same browser, as the same account, at another company's start URL or at the platform login adds to what the session opens. Nothing already open is lost, and switching between those companies never asks again. Someone who signed in at Acme's start URL and then at Globex's has both. Someone who signed in at the platform login and then at Acme's start URL has Acme and every company that does not require its own sign-in. Opening the start URL of a company the session has not signed in at shows that company's sign-in form with the person's email filled in.
- A company the person creates, or joins by accepting an invitation, is added to the session that did it, wherever that session signed in. It opens there the way it would after signing in at the platform login: while the company does not require this person to sign in through its access portal. When it does, at that moment or later, they sign in at its start URL first.
- Signing in as a different account replaces the session. A browser holds one account at a time.
- The session keeps what it has opened while it lasts, across page reloads and browser restarts. Signing out ends all of it at once.
- Each sign-in is recorded in the person's access history with where it happened: a sign-in at a company's start URL is marked Access portal for that company, and one at a portal App Through {App}.
For API clients, the caller profile (GET /v1/auth/me) lists the companies the session opens or can sign in to, and its platform_sign_in field says whether the session signed in at the platform login. Selecting a company the session does not open returns HTTP 403 with portal_sign_in_required and the portal_url to sign in at, and requests for that company's data are refused until then.
Where people land after sign-in
After signing in, whether with a password, a multi-factor code, or single sign-on, the platform picks a destination. The companies counted below are the ones the session lists (see Signing in to several organizations): every company the person belongs to after signing in at the platform login, and only the companies signed in at, plus any created or joined since, after signing in at a company's start URL. The first rule that applies wins:
- A specific destination. If the person was asked to sign in on the way to a page (for example, by opening an app link), they return there. That page still checks their access: a console page sends an app-only member to the apps start page.
- No company yet. They land on the organizations page, where they can accept an invitation or create a company.
- Exactly one company. They go straight in, by the company rule below. This includes someone who belongs to several companies and signed in at one company's start URL.
- Several companies. The organizations page lists them, and they pick one. Each company opens by the company rule.
The company rule: the portal App when the membership's access portal is a portal App they can open; the apps start page when it is the apps start page, an App they can't open, or the person has no console access there; otherwise the console. Someone who signs in at a company's start URL lands on that company's apps start page, and someone who signs in at a portal App stays in that App.
Coming back to the site while still signed in returns the person to the last company they chose, by the same rule, as long as the session still lists that company; otherwise to another company it lists. Switching company from the console follows the same rule. Switching from the apps start page always opens the other company's apps start page; from there, people with console access in that company can choose Open console. A company that requires sign-in through its access portal for this person sends them to their access portal to sign in instead, whichever way they arrive.
Where people land is decided by these rules and by each membership's console access and access portal. Administrators set the access portal for the whole organization in IAM → Sign-in and per membership in IAM → Users.
Company icon and logo
A company has two images, both set in IAM → Profile:
- Icon, a square image (the picture companies set before logos existed). It appears next to the company in the company switcher and the company pickers, on the organizations page, and as the browser tab icon on the company's start URL. Without one, those places show the company's initials.
- Logo, a wide image with two slots named by the background it sits on: Logo for light mode and Logo for dark mode. It appears in the console sidebar header, in the header of the apps start page, and on the signed-out sign-in page at the start URL. In the dark theme the platform shows the dark-mode logo and in the light theme the light-mode one; when only one is uploaded, it is used in both.
Fallbacks:
- the console sidebar and the apps start page header show the platform logo when the company has no logo; they never show the icon there, so a company that set only an icon sees the platform logo in the sidebar until it uploads a logo;
- the sign-in page at the start URL shows the logo, else the icon with the company name, else the platform logo;
- an image that fails to load falls back the same way.
Both images accept JPEG, PNG, WebP, or GIF up to 5 MB, and removing one takes effect at once. Changing either requires iam:company:settings (the Owner role by default). Step-by-step: IAM guide, Brand your organization.
Sign-in methods
A company chooses how its members may sign in: Email and password, Google, Microsoft, or any combination. Every company starts with all three. A list without password makes the company SSO only: its members sign in with Google or Microsoft. There is no separate “require SSO” setting; the list is the setting, and it keeps at least one method.
- The sign-in page at the company's start URL shows only the allowed methods, and the platform refuses the others there.
- The methods apply to every session that opens the company, wherever it signed in. A member who signed in at the platform login with a password, in a company that left password out, is sent to the company's start URL to sign in with an allowed method when they open it. Their other companies still open.
- A session that was open when the company changed its methods is asked once, the next time it opens the company, if it signed in with a method the company no longer allows or began before these settings existed. While a company keeps the starting settings, nothing is checked and nobody is asked again.
Owners can always get in
An owner who has a password and two-factor authentication set up can always sign in at the start URL with their password and code, even when the company is SSO only, so a broken single sign-on setup never locks the organization out. The sign-in page offers it under Owner? Sign in with password, and the sign-in is recorded in the owner's access history. Saving settings that would refuse the way you are signed in right now is refused too: sign in with a method the new settings accept (with your code, when they ask for it), then save.
Allowed SSO domains
A company can accept Google and Microsoft sign-ins only from its own organization at the provider: the Google Workspace domains and Microsoft tenant IDs it lists. The platform checks what the provider reports about the account (the Workspace the Google account belongs to, the Microsoft Entra tenant that signed it in), never the email address. A personal Gmail account, or an account from another Workspace that happens to use a matching-looking address, is refused.
- Both lists are empty to start with, which accepts any Google or Microsoft account.
- When either list has entries, the other provider accepts only what its own list names: listing a Google Workspace domain and no Microsoft tenant turns Microsoft sign-ins away. Remove Microsoft from the methods too, so the sign-in page does not offer it.
- Password sign-ins are not affected; leave password out of the methods to accept only your SSO accounts.
- Like the methods, the lists apply to every session that opens the company, and a session from an account outside them is sent to the start URL.
Two-factor on every sign-in
Require two-factor authentication for all members applies to Password sign-ins by default: a Google or Microsoft sign-in relies on the provider's own two-factor settings and is not asked for the platform's code. Set Applies to to Every sign-in to add the platform's code after Google and Microsoft sign-ins as a second layer. Someone invited to a company that requires two-factor sets it up before the invitation can be accepted.
- After the provider signs the person in, the sign-in page asks for the code from their authenticator app (or a recovery code) before the session starts. Someone without two-factor set up sets it up first, as with a password sign-in.
- At a company's start URL, only that company's choice counts. At the platform login, a person who belongs to several companies is asked for the code when any company the platform login opens for them requires it on every sign-in; a company that requires its own start URL does not count there.
- A session that signed in without the code, for example before the company chose this, is sent to the start URL to sign in again when it opens the company.
- The access history marks a single sign-on that entered the platform's code with + code, for example SSO (google) + code.
Sign-in protection per organization
Sign-in protection in IAM → Sign-in sets how many failed attempts lock an account, how long the lock lasts, and how long a session may stay idle. Each sign-in page follows its own values.
- At a company's start URL, and at its portals, that company's values apply, for its members. Failed attempts there lock the person out of that company's sign-in only, and the lock shows in that company's access history. A start URL of a company the person does not belong to counts as the platform login.
- At the platform login, the strictest values across the companies it opens for the person apply (a company that requires its own start URL does not count). For the idle timeout, only companies that set a value count.
- Too many failed attempts across all sign-in pages together lock the account on every one of them for a while, whatever each company set.
- Signing in at a page clears only that page's failed attempts. Signing in elsewhere clears neither them nor the count across all pages, since that sign-in may not have asked for this page's code.
- Each sign-in page in a session keeps its own idle clock, moved by using a company it opens. A page idle past its timeout signs out alone: companies opened only through it ask for a new sign-in there, and the person keeps working in companies opened through other pages. The session ends when no page is left.
- Resetting or changing the password, or a platform operator unlocking the account, lifts every lock at once.
- A locked sign-in page answers exactly like a wrong password, so nobody can learn from it that an account exists or is locked.
Portals
A portal is an app that carries the company's own sign-in page. People open the app's address, /apps/{company_slug}/{app_slug}, see a sign-in screen the company designed (its logo, its words, its layout), sign in there, and continue straight into the app. A company can have several portals, for example one for customers and one for field staff.
- It counts as the company's sign-in. A sign-in at a portal is a sign-in at the company, exactly like one at its start URL: it satisfies Require sign-in through access portal, it is recorded in the access history as a sign-in through that App, and the company's sign-in methods, allowed SSO domains, two-factor requirement, sign-in protection, and working hours apply to it without any work in the app.
- The session is company-wide. Signing in at a portal never signs someone in to one app only. Afterwards the person's other apps in that company, and the console if they have console access, open without another sign-in.
- The sign-in screen is public. Anyone can open it without an account, so it never holds confidential content.
An app becomes a portal when it has an auth module (next section), a version with that module is published, and someone with iam:company:settings marks it as a portal. What people see at an app's address:
| Situation | What they see |
|---|---|
| Signed out, at a portal | The portal's sign-in screen, inside a platform frame that shows the company name, a language picker, and a line saying the platform secures the sign-in |
| Signed in elsewhere, and the company asks for its own sign-in | The portal's sign-in screen; signing in there adds the company to their session and keeps their other companies open |
| Already signed in to the company | No sign-in screen: the app, or the screen saying they don't have access to it |
| Signed out, at an ordinary app | The company's built-in sign-in, then the app |
| The portal's sign-in cannot be fetched | The company's built-in sign-in, then the app. A sign-in screen that loads but breaks while running is not replaced; fix and republish it, or unmark the app |
The start URL /apps/{company_slug} | Always the built-in sign-in, whatever portals the company has |
Unmarking a portal, or archiving or deleting the app, returns its address to the built-in sign-in. Archiving or deleting a portal unmarks it and needs the same company settings permission as marking; unarchiving does not mark it again. Owners can always use the start URL, including its owner fallback when the company is SSO only.
A portal can be the access portal where people land after signing in, for the whole organization or for single members. Its main module can list the other apps the person may use and open one of them with the launcher tools apps.launcher.list and apps.launcher.open; see the Apps guide.
Not in this release
A portal cannot create accounts: people still join a company by invitation.
Auth module and main module
An app is made of modules, declared in its ergon.json under modules:
- The main module (
modules.main,main.tsxunless it names another file) is the app itself. It opens only after sign-in and only for people who may use the app, and every tool call it makes runs as that person under the app's tool policies. - The auth module (
modules.auth, usuallyauth.tsx) is the sign-in screen. It is built into a separate bundle of the same version and shown to people who are signed out.
The auth module only draws the screen. Every sign-in step is the platform's:
- It can call only the platform's sign-in functions (
window.ergon.auth): sign in with a password, enter a two-factor or recovery code, start Google or Microsoft sign-in, request and complete a password reset, resend the verification email, and set up two-factor. It cannot call tools or read files, and it cannot fetch anything or load scripts, fonts, or images from other addresses. - It does see what the person types into it, because it draws the inputs, and hands it to the platform. That is why, on an app marked as a portal, publishing a changed auth module needs the company settings permission, and why a portal's sign-in is only ever offered for the company that owns the app. It never receives tokens, cookies, the two-factor challenge, the password reset token, or the session; those stay with the platform and never reach app code.
- Google and Microsoft sign-in always leaves for the provider in the whole browser window, never inside the app, and comes back to the app's address.
- A password reset requested from a portal emails a link back to the portal's address when the account is a member of the company. For anyone else the email carries the platform's usual reset link instead, and the portal gets the same answer either way, so it never learns which emails belong to the company. Someone already signed in who opens a portal's reset link goes to the platform's reset page.
- It offers only the sign-in methods the company allows, and may offer fewer. Whatever it shows, the platform refuses a method the company does not allow.
- It never decides who gets in. The platform signs the person in, checks whether they may use the app, and tells the auth module the outcome.
Everything in the auth module is public
Anyone can load the auth module and every file it imports without signing in. Never put confidential text, internal links, customer data, or anything you would not publish on your website into it. The company logo is part of the app, imported as an asset, since the sign-in screen cannot load images from other addresses.
Because the auth module is the company's sign-in page, changing it is a company decision: on an app marked as a portal, publishing a version whose auth module differs from the published one needs iam:company:settings, and a version without an auth module cannot be published until the app is unmarked. Building one step by step: Apps guide, Build a portal.
Sign-in outcomes
When a sign-in at a portal completes, the platform first checks whether the person may use the app, and only then decides what to show. The sign-in screen never tells someone they are in when they cannot enter.
- Entered. Signed in and allowed to use the app. The platform removes the sign-in screen and opens the app fresh; nothing from the sign-in screen carries over.
- No access. Signed in, but not allowed to use this app. The platform shows its own screen, “Signed in as {name}; you don't have access to this app”, with links to go to their apps, accept a pending invitation to this company, or switch account. The app's own code is never loaded for them.
- Failed. Wrong password or code, an unverified email, a method the company does not allow, outside working hours (saying when they can sign in again, when that is known), an expired reset link, and similar. The sign-in screen stays and says why.
In between, the platform may ask for a two-factor code, ask the person to set up two-factor first (the company requires it), or confirm that a reset email was sent. Someone already signed in who opens a portal they may not use goes straight to the no access screen, without a sign-in screen.
Who decides what
| Setting | Belongs to | Who may change it | Default |
|---|---|---|---|
| Console access | One company membership | Anyone with iam:company:members:manage on that member (the Owner and Admin roles by default), never for themselves; only owners for another owner | On |
| Access portal | The company | Anyone with iam:company:settings (the Owner role by default), in IAM → Sign-in | Default |
| Require sign-in through access portal | The company | Same as the company's access portal; needs an access portal other than Default | Off |
| A member's access portal | One company membership | Anyone with iam:company:members:manage on that member, including on their own membership; only owners for another owner | Inherit |
| A member's Require sign-in through access portal | One company membership | Same as a member's access portal; On needs Apps start page or a portal App as their own or inherited access portal | Inherit |
| Company icon and logo | The company | Anyone with iam:company:settings (the Owner role by default), in IAM → Profile | None (initials for the icon, the platform logo for the logo) |
| Sign-in methods and allowed SSO domains | The company | Anyone with iam:company:settings (the Owner role by default), in IAM → Sign-in, while signed in a way the new settings accept | Password, Google and Microsoft; any domain |
| Two-factor requirement and its scope | The company | Same as the sign-in methods | Off; password sign-ins only |
| Sign-in protection | The company | Anyone with iam:company:settings (the Owner role by default), in IAM → Sign-in | The platform's values |
| Portal mark | The app | Anyone with apps:apps:manage on the app and iam:company:settings on the company (the Owner role by default); needs a published version with an auth module | Off |
| A portal's sign-in screen | The app | Editors of the app write it; publishing a changed one on a portal also needs iam:company:settings | None |
| Use of an app | The app | Whoever manages access on that app's security page | Nobody but its owners |
These settings are independent. Console access decides whether a person may use the console; the app's grants decide which apps they may use; the access portal decides where they land; the sign-in requirement decides where they sign in. An app-only member with no app grants signs in to an empty apps start page. Step-by-step instructions are in the IAM guide under Give someone app-only access and Force sign-in through your start URL.
Worked example — field technicians
A maintenance company has an operations team that builds and runs its processes in the console, and forty field technicians who only need to log visits. The operations team builds a “Visit log” app that creates items in the maintenance workflow.
- An administrator invites the technicians and adds them to a “Technicians” team. Once each technician has accepted, the administrator switches off their console access: it can't be set on a pending invitation, and until it is switched off they have console access.
- The app's owner grants the Technicians team the User preset on the app, and the team receives the workflow permissions the app needs to create items.
- A technician signs in and lands on the apps start page, which shows only “Visit log”. Logging a visit creates the workflow item as that technician.
- If a technician tries to open the workflow in the console, or calls the workflow API with their own sign-in, the platform refuses with
console_access_denied. - In IAM → Sign-in the administrator sets the organization's access portal to Apps start page and switches on Require sign-in through access portal, then shares the start URL
/apps/acme-maintenance. Every technician inherits both and signs in there, under the company's logo; one who signs in at the platform login is sent to that address to sign in again. The operations team keeps signing in at the platform login and landing in the console: the administrator sets their access portal to Default in their Access section.
The technicians remain ordinary members: they show up in IAM → Users, belong to a team, and appear in the audit trail under their own names.