How Plane SSO works on a self-hosted workspace
On self-hosted Plane, SAML and OIDC single sign-on are paid-plan features, available from the Pro plan and above, and LDAP support is listed as an Enterprise feature. That makes the protocol and plan decision the first step, before any identity provider configuration begins. A security or IT team putting Plane behind its existing identity provider should confirm which protocol that provider supports, which Plane plan it will buy, and who signs off on both. Those answers determine the rest of the rollout, including which edition gets installed and how users are admitted to the workspace.
The work is harder than it looks because the Community Edition does not include paid-plan identity features. Community is licensed under AGPL-3.0 and matches the feature set of Plane Cloud's Free tier. To move to a paid plan, a self-hosted Community install must first switch to the Commercial Edition, which uses a license key. The Commercial Edition is a proprietary codebase with its own release cycle, so the switch should be treated as a planned change with its own testing window, not a settings change. Ask Plane to confirm the exact steps for your installed version, including how the license key is applied and how existing data is carried across.
Seats are the second place where identity choices carry cost. On the Commercial Edition, seats are counted by users with paid roles, so the way accounts are created and assigned roles directly affects the bill. Before go-live, confirm with Plane whether a first sign-in through SSO creates a workspace membership automatically, which role that membership receives by default, and whether that role consumes a paid seat. A useful test is to sign in with a few illustrative accounts on a staging instance and record how the seat count changes after each step. Repeat the test for a user who should not have access.
Identity choices also shape role management after launch. Once users sign in through the identity provider, someone must decide whether Plane roles are set inside Plane, derived from groups in the identity provider, or updated by an automated sync. Confirm which of these Plane supports on your plan, including whether group-based role mapping or user provisioning is available, since those features are not covered by the protocol support described above. Write the group-to-role mapping down before cutover, and confirm what happens to a user's seat and access when they leave the identity provider, so that offboarding does not leave paid seats assigned to people who no longer work for the organization.
Which identity components and settings are involved
Identity integration touches five places: the license on the installation, the sign-in method set for the workspace, the identity provider application, the user and role model that drives seats, and the self-hosted services that handle sign-in and redirects. Each has a different owner, so agree on those owners before configuration starts. Check each setting against the admin documentation for your Plane version.
Commercial Edition license key
A self-hosted Community install must switch to the Commercial Edition before a paid plan, including SAML and OIDC, can be enabled. The license key is applied to the installation and unlocks the paid plans, so the platform administrator who manages vendor licensing should own it. Confirm in the Plane admin settings for your version where the key is entered, how the active plan is displayed, and whether a plan change requires a restart or redeploy of the services.
Workspace sign-in method
The sign-in method decides which protocol the integration uses: SAML, OIDC or LDAP. Plane's pricing page lists SAML and OIDC from the Pro plan upward and LDAP under Enterprise, so the plan choice limits the protocol options before any technical work begins. Confirm whether password sign-in stays available alongside the chosen method and who may still create accounts directly. The workspace admin usually owns this setting, with platform admin approval.
Identity provider application or client
The identity provider needs an application or client registration that represents Plane, with a protocol type that matches the sign-in method. Your identity team usually owns it, and it holds the callback addresses, signing certificates or client secrets, and the user attributes sent to Plane. Record who can rotate secrets and certificates, since an expired value blocks sign-in for every user. Confirm the exact callback addresses and attribute names in the Plane documentation for your version.
User and role model for seats
Plane counts seats by users with paid roles, so the roles assigned to each person determine what the workspace costs to run. Decide whether roles can be driven by identity provider groups or claims, or whether they are assigned inside Plane after first sign-in. Ask who approves role changes and how a departing user's seat is released. Confirm in the admin settings for your version which role values sync from the identity provider and which must be set by hand.
Self-hosted sign-in and redirect services
The sign-in flow passes through services you run: the Plane web and API services, plus the reverse proxy or load balancer that terminates TLS. Redirect URLs must match the public address users reach, so a changed domain or proxy path can break sign-in even when the identity provider is healthy. The platform team owns these services and their certificates. Confirm the public base URL and proxy settings in the Plane setup documentation for your deployment method, Docker Compose or Kubernetes.
Choosing between SAML, OIDC and LDAP on Plane
This table compares SAML, OIDC and LDAP for self-hosted Plane across the identity provider you run, where the directory sits, the plan each requires, and the ongoing operational work each one creates. Read each row against your own identity estate, then check the plan and license notes below before committing to a design.
| Option | When it fits | Plan required | Ongoing operational cost |
|---|---|---|---|
| SAML | Your identity provider supports SAML 2.0 and you want browser sign-in federated from a corporate IdP such as Entra ID, Okta or ADFS (confirm your IdP's support with its vendor) | Pro and above on self-hosted Plane, per Plane's pricing page | Signing certificate expiry and rotation, metadata updates when endpoints change, attribute mapping for email and name, support for users locked out during IdP changes |
| OIDC | Your identity provider offers OpenID Connect and you prefer a modern token-based flow, or your IdP is a cloud service that favors OIDC over SAML | Pro and above on self-hosted Plane, per Plane's pricing page | Client secret rotation, redirect URI maintenance when the Plane domain changes, scope and claim configuration, token lifetime settings agreed with the identity team |
| LDAP | Users and groups live in Active Directory or another LDAP directory inside your network and you need directory-backed sign-in rather than a cloud IdP | Enterprise only on self-hosted Plane, per Plane's pricing page | Service account password rotation, network path from the Plane backend to domain controllers, TLS certificate trust for LDAPS, directory search scope and group changes, more support load when directory queries fail |
| Directory location | Confirm where your users are authoritative before choosing: cloud directory favors SAML or OIDC, on-premises directory with no federation favors LDAP | Determines whether your plan tier must support LDAP | Cloud IdPs need outbound reachability from users' browsers and the Plane callback URL; LDAP needs inbound-to-directory reachability from your Plane network segment |
| Existing federation | Your organization already federates applications through one IdP, so reusing its SAML or OIDC app registration avoids a second trust path | Pro and above for SAML or OIDC, so a Community install needs the Commercial Edition first | Adding Plane as another relying party adds one more application to review in access certification and offboarding runs |
| Commercial Edition and license | Any paid plan on self-hosted Plane requires the Commercial Edition with a license key, since the Community Edition has no paid plans | Commercial Edition and a license key apply to all of the above | Seats are counted by users with paid roles, so SSO-provisioned accounts still count against the license; confirm seat logic with Plane before go-live |
Build sequence for connecting Plane to your identity provider
This sequence connects a self-hosted Plane workspace to your identity provider so people sign in with existing accounts and receive workspace roles from identity attributes. Each step closes with a check you can run before moving on, so a fault surfaces at the step that caused it.
Confirm the edition and plan you need
Choose the protocol first, because the plan decides what Plane allows. SAML and OIDC are listed for self-hosted Plane on Pro and above, while LDAP is listed as an Enterprise feature, so an LDAP requirement points to a different plan than SAML or OIDC. Confirm which edition your instance runs, and ask Plane or your account contact to confirm plan availability for your seat count in writing, since the public pricing page does not replace that confirmation. Done when you have a named edition, a named plan and a supported protocol recorded in your design notes.
Switch from Community to Commercial if needed
Skip this step if you already run the Commercial Edition. A Community install must move to the Commercial Edition before a paid plan can be activated, and the plan is applied with a license key. Take a backup of the database and object storage first, then follow the edition switch steps in the documentation for your deployment method, whether Docker Compose or Kubernetes with Helm. Sign in with your existing admin account afterward and confirm that projects, members and roles are intact. Done when the instance reports the expected edition and plan and existing data loads without errors.
Register Plane as an application in the provider
In your identity provider, create an application entry for Plane using the protocol you chose in the first step. Assign only a pilot group so access stays limited while you test. Record the identifiers the provider issues, such as the client ID for OIDC or the entity ID for SAML, and store them in your secrets manager. Ask your identity team which signing certificate or client secret rotation process applies, and note the owner and renewal date. Done when the application appears in the provider's catalog with the pilot group assigned and the identifiers recorded.
Set redirect and callback URLs to the hostname
Enter the public hostname of your Plane deployment in the provider's redirect or callback fields. Use the exact scheme, host and path that Plane's self-hosting documentation specifies for your version and protocol, and confirm the path with the documentation rather than from memory. Mismatched URLs are a common cause of failed sign-in, so copy the value from the deployed instance and avoid retyping it. Confirm that the hostname resolves over HTTPS with a valid certificate. Done when the provider saves the URLs and a test request from the hostname reaches the provider login page without a redirect error.
Configure the chosen protocol in Plane
In Plane's authentication settings, enter the values from the provider. For OIDC, that means the issuer URL, client ID and client secret. For SAML, that means the identity provider metadata or entity ID, the single sign-on URL and the signing certificate. Use the field labels shown in your version of Plane, because labels can change between releases. Keep the client secret out of screenshots and tickets. Leave local password sign-in enabled for a break-glass admin account until the pilot test passes. Done when the identity provider sign-in option appears on the login page and the configuration saves without validation errors.
Map identity attributes to Plane users
Confirm that the provider sends the attributes Plane needs to create and match accounts: a stable unique identifier, an email address and a display name at minimum. Decide which claim or attribute carries group membership, then map provider groups to Plane workspace roles. Decode a token or inspect a SAML assertion from a pilot account to confirm the claim is present with the expected name and value. Done when the decoded token or assertion shows the mapped claim and a pilot user lands in the workspace with the role you expected.
Test sign-in with a pilot group
Have a small pilot group sign in through the provider. Include at least one workspace admin and one member with a limited role so both paths get exercised. Ask each person to confirm they reach the correct workspace, can open the projects they should see, and cannot open projects outside their role. In the Plane user list, check that each pilot account was created once and that seat use matches your expectation. Keep the break-glass admin available during testing. Done when every pilot account signs in, shows the expected role and appears once in the user list.
Restrict sign-up and confirm deprovisioning
After the pilot passes, restrict self-service sign-up so new accounts come only through the identity provider, and confirm the sign-up setting matches your access policy. Test deprovisioning by disabling a test account in the provider and confirming that sign-in to Plane is blocked. Ask Plane or your vendor contact how removed users are handled for your version, since session lifetime and existing access can differ. Review who holds admin roles and document the break-glass procedure. Done when an account outside the assigned group cannot sign up, a disabled test account cannot sign in and the admin list matches the approved roster.
Managing workspace roles and seats from your identity provider
Role assignment in a self-hosted Plane workspace is a licensing decision as well as an access decision. On the Commercial Edition, seats are counted by users with paid roles, so the role a person holds at sign-in can change what your organization pays for. Before you connect SAML, OIDC or LDAP, decide who should be a paid-role member, who should remain a lower-cost member, and who should have no access at all. Those answers determine whether roles belong in Plane, in your identity provider, or in both.
There are two practical patterns. In the first, your team signs people in through the identity provider and then an administrator sets each user's role inside Plane. This is simple to run for a small workspace, but every joiner, mover and leaver needs a manual change, and a user who signs in with the wrong role can consume a paid seat until someone notices. In the second, roles or group membership arrive from the identity provider as claims or directory groups, so the assignment follows the person's HR-driven group membership. This reduces manual work but depends on the claim or group mapping being correct and on Plane applying it the way you expect.
Whichever pattern you choose, confirm with Plane, for the specific protocol you plan to use, whether it supports automated provisioning (such as SCIM-style user lifecycle changes), whether it can read group claims to set workspace roles, and whether directory group sync is available on your plan. Plane's pricing page lists SAML and OIDC on Pro and above and LDAP among Enterprise features for self-hosted installs, but it does not, in the material supplied for this page, describe provisioning or group sync. Treat any assumption about these features as unconfirmed until Plane's documentation or account team states it in writing.
Before go-live, run a short test with a few accounts across each role. Sign in as a new user, confirm which role Plane assigns, and check the seat count in the admin view. Then remove that user from the relevant group in your identity provider and confirm what happens on the next sign-in and whether the seat is released. Record the results. These checks show whether seat consumption will match your expectations and give you evidence for the procurement and finance conversations that follow.
Plan for drift. Roles change, contractors leave and groups get renamed. Assign one owner to review the role-to-group mapping on a fixed schedule, and ask Plane to confirm how it handles users removed from the identity provider, including whether their seats are reclaimed automatically. If it does not, the seat review becomes an operational task with a named owner rather than an assumption about the software.
How Docker Compose and Kubernetes change the SSO rollout
Docker Compose is the documented route for small and mid-size teams, and it is usually the simplest place to test SAML or OIDC against one Plane instance. All services run on a single host, so the identity provider only needs to reach one public address. SAML and OIDC on self-hosted Plane are listed on the Pro plan and above, so a Compose install that needs SSO must move from the Community Edition to the Commercial Edition and apply a license key first.
- Edition and plan: Confirm the Commercial Edition and the plan level before you configure SSO, because the Community Edition does not provide SAML or OIDC on self-hosted Plane.
- Redirect URLs: Register the callback address with your identity provider using the public hostname your reverse proxy serves. Confirm the exact callback path in the release you deploy.
- TLS termination: TLS is usually terminated at a reverse proxy in front of the containers. Confirm the proxy forwards the original scheme and host so that generated callback URLs use https.
- Secret handling: Confirm where the SSO client secret is stored in your environment files and who can read those files on the host.
- Login testing: Test with a standard member account first, then with a user who holds a paid role, so you can confirm both sign-in and seat assignment.
Confirm the callback path, scheme and hostname against the version you install before any user signs in.
The Kubernetes guide is the documented route for high availability, and it installs the Commercial Edition. The web and API components can run as several replicas, which means the identity flow must survive a request landing on a different pod than the one that started the login. The Helm chart can point PostgreSQL, Redis or Valkey, RabbitMQ and S3-compatible storage at external managed services, so the state that sign-in depends on can live outside the cluster.
- Canonical hostname: Use one public hostname on the ingress and register that exact callback URL with the identity provider once. Confirm that every replica generates the same URL.
- TLS at the edge: Terminate TLS at the ingress controller or load balancer, and confirm that secure cookies and https callbacks work through it. Check the chart's TLS settings for your ingress class.
- Shared session state: Confirm that Redis or Valkey is external and shared across replicas, so a login is not lost when a pod is replaced.
- Failover test: Restart one pod while a login is in progress and confirm the flow completes. Repeat during a rolling upgrade.
- Clock and assertions: Confirm time synchronization across nodes and the identity provider, since SAML assertion validity windows and token checks depend on accurate time.
Confirm the chart version, the license key and the external service endpoints in your own environment before you run the failover test.
An air-gapped install runs inside an isolated network, so the identity provider must be reachable from inside that network. The Airgapped edition applies here. It is a separate proprietary codebase with its own release cycle, so SSO updates follow that cycle rather than the Community or Commercial schedules. Metadata, signing certificates and key material have to be loaded into the environment by hand, which makes the update path part of the rollout plan.
- Edition and licensing: Confirm with your Plane account team which features the Airgapped edition includes, including SAML and OIDC, and what license applies.
- Internal reachability: The identity provider host must resolve and accept connections from the Plane network segment. Test DNS, routing and firewall rules before configuration.
- Redirect URLs: Callback URLs use the internal hostname. Confirm that the identity provider accepts that hostname and that no external-only domain is required.
- Internal certificates: Confirm that Plane and the identity provider trust the internal certificate chain. Document how signing certificates are rotated without internet access.
- Offline metadata updates: Confirm how identity provider metadata and key sets are refreshed and who approves each change.
If you run the air-gapped install in multiple replicas, repeat the shared state and failover checks from the Kubernetes route before go-live.
What drives identity integration effort and how to keep it down
This table lists the drivers that change how much work a Plane identity integration takes, and a practical way to reduce each one. Read each row as a decision point: effort rises when the driver stays open and falls when it is settled before build starts. The main takeaway is that protocol choice, role mapping and the test environment cause most rework, so settle them first.
| Driver | How it raises effort or cost | How to keep it down |
|---|---|---|
| Number of identity providers or directories | Each provider adds its own callback settings, attribute mappings and test cases | Use one identity provider per workspace where the business allows it |
| Protocol choice (SAML, OIDC or LDAP) | LDAP is listed as an Enterprise feature, so the protocol can change the plan required | Confirm protocol and plan with Plane before design starts |
| Number of workspaces and environments | Each workspace and environment needs its own configuration and test pass | Use a single test tenant and promote settings in a fixed order |
| Group and role mapping complexity | Plane roles drive seat counts, so unclear mapping causes rework and seat disputes | Agree the role mapping in writing before any build work begins |
| Use of custom claims | Non-standard claims need extra attribute work and can fail without a clear error | Limit claims to what Plane needs and test with sample users |
| Network path between Plane and the provider | Firewall and proxy rules for provider endpoints add review cycles in self-hosted networks | Map required endpoints early with the network and identity teams |
| Compliance evidence needs | Assessors may ask for configuration records, access reviews and change history | Define the evidence list at scoping and export configuration in a fixed format |
How to test Plane SSO sign-in and failure paths
The purpose of SSO testing is to prove that each sign-in path admits only the people you intend, gives each of them the right workspace role, and fails closed when something goes wrong. Start by writing the test plan against your own identity provider groups and Plane workspace roles, not against a generic checklist. Run every case in a dedicated test workspace on the same edition, version and identity configuration you plan to use in production, because a passing test on a different build proves little. Confirm the exact protocol you are testing (SAML, OIDC or LDAP) and the plan it requires before you start, since the availability of these methods on self-hosted Plane depends on the plan, as described in the pricing notes for this topic.
Cover successful sign-in for each role type you will assign in Plane, including administrators, members, guests or any custom role your organization uses. For each role, sign in through the identity provider, confirm the user lands in the correct workspace, and check that project and module visibility matches the role. Then test the negative cases that matter most: a user who exists in the identity provider but has no assigned seat, role or group membership, and a user who has been disabled or removed. The expected result is a denied sign-in with no new Plane user record and no partial account. Check the Plane user list and the database before and after each attempt, so you can show the reviewer that nothing was created. Confirm the outcome for a user who is removed from the identity provider while holding an active Plane session.
Test sign-out from Plane and from the identity provider, and confirm which one ends the other. Then test session expiry by letting an idle session lapse and by forcing a re-authentication, recording how long the session remains valid as configured in your environment. Next, rotate the signing certificate for SAML or the client secret for OIDC in a staging copy, and verify that sign-in fails until the new credential is loaded and succeeds afterward. Record the exact rotation steps, because the window between the identity provider change and the Plane configuration change is where most production outages occur. Confirm that the old certificate or secret no longer works once rotation is complete.
Test what happens when the identity provider is unreachable, for example by blocking its endpoint at the network layer in the staging environment. A safe failure means users see a clear error, no session is granted, no account is created or modified, and local access paths behave as your documented break-glass policy specifies. Also confirm that local sign-up is restricted as intended. Attempt to register a new account through the sign-up page and any invitation flow, and verify the result matches your sign-up policy. Do not treat a disabled button as proof. Test the endpoint directly.
Store the evidence in a form an internal reviewer can reproduce. For each case, record the test identifier, the date, the Plane edition and version, the identity provider configuration reference, the user account used, the expected result, the observed result, and the relevant log lines or screenshots. Keep the before and after database counts for denied cases. Remove real personal data from the evidence, and keep test credentials out of the record. Agree in writing with your security or compliance lead which failures block go-live and which are accepted risks with an owner. If your organization wants an independent review of this test evidence, confirm with the reviewing party which artifacts they require before the tests run.
Securing SSO secrets, admin access and sign-in paths
Identity integration adds credentials and sign-in paths that attackers target early. The cards below cover the controls that sit directly on the SSO connection, from credential storage to recovery. Wider platform controls, such as instance-wide TLS, database security, backups and patching, are covered in the Plane security hardening topic.
Client secret and signing certificate storage
The OIDC client secret or the SAML signing certificate and its private key are the credentials that make your identity provider trust Plane. Keep them out of Compose files, Helm values committed to version control and container images. Inject them at runtime from your secrets manager, restrict who can read them and record that list. Ask the identity provider team for a documented rotation procedure before go-live.
Credential expiry and rotation
SAML signing certificates and OIDC client secrets expire, and an expired credential can stop sign-in for every user at once. Record each expiry date in your change calendar, set alerts well ahead of it and rehearse the rotation in a non-production workspace first. Confirm with your identity provider whether it can publish a new certificate alongside the old one, so the switch does not require a sign-in outage.
Administrative and God Mode access
God Mode is the instance-level administrative area of self-hosted Plane, and whoever reaches it can change the sign-in configuration itself. Limit it to a named group of platform administrators, and confirm in the Plane documentation how it is enabled and who can open it on your edition. Review that membership on a fixed schedule, and do not share one administrator account between people. Confirm whether workspace roles can be mapped from identity provider groups on your plan.
HTTPS on sign-in and callback endpoints
The sign-in address and the callback address that the identity provider redirects to must use HTTPS with a certificate that users' browsers trust. Register only the exact callback URLs in the identity provider, without wildcards, and make the public base URL configured in Plane match the address users actually type. Hostname mismatches and plain HTTP redirects are common causes of failed or downgraded sign-ins.
Self-registration after SSO goes live
Once SSO is the intended entry point, decide whether Plane should still accept email sign-up and password sign-in. Review the sign-up settings on the instance, confirm which login methods remain enabled and test with an account that has no identity provider assignment. Document the decision, because a forgotten local sign-up path can let accounts exist outside your identity provider's control.
Recovery path independent of the identity provider
If the identity provider is unavailable, misconfigured or its certificate has expired, administrators still need a way into Plane. Plan a break-glass administrator with a separate credential held in your secrets manager, and test that login before go-live. Confirm with the vendor and in your own environment which local login remains available when SSO is enforced, and write the recovery steps into your runbook.
What to monitor, back up and document after SSO goes live
Cutover is not the end of the identity work. Once users sign in to self-hosted Plane through SAML, OIDC or LDAP, someone needs to own four recurring checks: sign-in failures, redirect errors, credential expiry and seat consumption. Start by deciding who receives these signals. Your identity provider's sign-in logs will show rejected assertions, unknown users and failed token exchanges, while Plane's own application and reverse proxy logs will show callback errors. Confirm with your identity team which log sources they can export, how long they are retained, and whether an alert can fire when failures spike after a change to DNS, TLS or the Plane base URL. A redirect URI that no longer matches the registered value is one of the most common post-cutover breakages, so include it in the first alert set.
Certificates and client secrets expire on their own schedule, independent of Plane releases. For SAML, track the signing certificate that Plane trusts and the metadata you published to the identity provider. For OIDC, track the client secret or any client credential used for the token exchange. Record each expiry date in your change calendar with an owner and a renewal window, and confirm with your identity provider how it handles rollover, because some providers let you publish a second certificate before the first one lapses. Rotate on a schedule rather than in an emergency. Keep the procedure in a runbook that names the Plane configuration values to change and the restart or redeploy step required after each change. Seat counts need a separate review. On the Commercial Edition, seats are counted by users with paid roles, so a group sync that grants roles broadly can increase cost without anyone noticing. Compare the seat count shown in Plane's administration area with the membership of the identity groups mapped to paid roles, and check whether users who left the organization are deprovisioned in Plane. Confirm with Plane which plan and seat terms apply to your license before you set a review cadence, because the pricing page lists plans and per-user figures that may not match your contract.
Before every Plane upgrade, back up the configuration and secrets that the identity integration depends on. That includes the environment values for the identity provider, the client identifiers, the signing material held in your secrets store, the Helm values or Compose files, and the database that holds users and workspace memberships. Store backups where the restore can be tested, and record which Plane version each backup belongs to. Upgrades follow the separate release cycles of each edition, so a Community release does not tell you what the Commercial build changed. After every upgrade, rerun the sign-in test for each protocol you use, verify group-to-role assignment for at least one user per role, and confirm that the redirect URIs still match. The step-by-step upgrade process is covered in the Plane upgrades and support topic, so use that page for sequencing.
Finally, document the mapping of identity groups to Plane roles. The document should list each identity provider group, the Plane workspace or project role it grants, whether that role is a paid role, who approved the mapping, and the date it was last reviewed. Include the rule for users who belong to several groups, since the outcome depends on how your configuration resolves conflicts. Keep the mapping under version control next to the configuration, so auditors and new administrators can see what changed and when. Illustrative example: if a group named engineering-leads maps to a role that consumes a paid seat, a quarterly review should confirm that the group membership still reflects current responsibilities.
What buyers and engineers ask about Plane SSO cost, effort and setup
Which Plane plan is required for SAML or OIDC single sign-on?
On self-hosted Plane, SAML and OIDC are available on the Pro plan and above, according to Plane's pricing page. Free installs do not include them. Pro is listed at 6 to 8 US dollars per user per month and Business at 13 to 15 US dollars per user per month, both billed per user. Enterprise Grid is priced on request. Because a paid plan on a self-hosted install requires the Commercial Edition and a license key, identity integration usually begins with an edition change and license setup, so include that step in your planning and in any written quote.
Why is LDAP listed as an Enterprise feature in Plane?
Plane's pricing page lists LDAP support as an Enterprise feature for self-hosted installs, grouped with API-enabled audit logs. The page does not explain the reasoning behind that grouping, so ask Plane to confirm the current LDAP scope before you plan around it. For your decision, LDAP is a plan question as much as a technical one. If your directory only speaks LDAP, request an Enterprise Grid quote, which is on request, and compare it with whether your existing identity provider can present SAML or OIDC to Plane. Confirm how directory groups map to Plane roles before you request the quote.
Can Plane Community Edition use SSO or does it need the Commercial Edition?
Plane Community Edition does not include the paid SSO features. It is licensed under AGPL-3.0 and matches the feature set of the Plane Cloud Free tier, and the pricing page places SAML and OIDC on Pro and above. To use SAML or OIDC on self-hosted Plane, a Community install must first switch to the Commercial Edition and then activate a paid plan with a license key. The Commercial and Airgapped editions are proprietary, so review the license terms with Plane before changing editions. Teams that do not need paid identity features can keep Community as an open-source option.
How does Plane count seats on a paid self-hosted plan?
On a paid self-hosted plan, seats are counted by users with paid roles, according to Plane's editions documentation. The number that drives your subscription is therefore the count of users who hold a billable role, which may differ from the total number of accounts in the workspace. Ask Plane which roles are billable, how roles that are not billable are treated, and whether users created through SSO on first sign-in count immediately. The Free plan includes 12 seats according to Plane's Kubernetes documentation. Request the seat counting method in writing, along with your expected seat growth over the contract term.
What does Plane SSO cost and which costs repeat each year?
The subscription is the published recurring cost, and setup is a separate one-time cost. Plane's pricing page lists Pro at 6 to 8 US dollars and Business at 13 to 15 US dollars per user per month, with Enterprise Grid on request. Infrastructure is another recurring cost: PostgreSQL, Redis or Valkey, RabbitMQ and S3-compatible object storage run on your hosts or cloud accounts, and you pay for them directly. Identity provider configuration, integration, testing and documentation are one-time costs that depend on the written scope. Ask every quote to separate setup, subscription and infrastructure, and to state which items repeat and how often they are billed.
What drives the effort of an SSO integration for self-hosted Plane?
Effort depends mostly on how many identity systems are involved and how much role mapping is required. A single OIDC provider with clear group claims is usually a smaller job than a SAML setup that maps attributes across several workspaces. Other drivers include whether Plane runs on Docker Compose or on Kubernetes with Helm, whether PostgreSQL and object storage are external managed services, how directory roles map to Plane roles, and how many test cases your security team requires before sign-off. Each of these adds planning, configuration and verification time, so ask for the effort estimate to list them separately.
What does the internal team need to provide for an SSO project?
The internal team usually provides an identity provider administrator, directory group design, the DNS name and TLS certificate for the Plane endpoint, and a named approver for role mapping. It also needs access to the hosting environment, such as the Kubernetes cluster or Docker host, and to the database and object storage that Plane uses. Someone must own test accounts and the acceptance criteria. Ask any proposal to list each input with an owner and a needed-by point, so the work is not held up by missing access. Confirm the exact requirements against your identity provider's documentation and Plane's self-hosting documentation.
Can an internal team set up Plane SSO without outside help?
Yes, an internal team with identity and platform skills can configure SAML or OIDC for self-hosted Plane once the paid plan and Commercial Edition are in place. Much of the work is configuration, testing and documentation, so the main question is capacity and ownership. Before you decide, confirm who will own identity mapping after go-live, who will handle upgrades across Plane's separate edition release cycles, and whether your security team needs documented evidence of the setup. A fixed-scope engagement with DeployOpen can cover the build and handover while your team keeps ownership. Ask for the written scope so you can compare it with your internal plan.
How DeployOpen scopes, builds and hands over Plane SSO work
DeployOpen scopes, builds and hands over Plane SSO and identity integration inside your own infrastructure, from identity provider configuration through to the workspace settings your administrators use. Engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts. Ongoing support and upgrades are available as a retainer.
How we scope
- Confirm the identity protocol (SAML, OIDC or LDAP) and the Plane plan each one requires before design starts
- Written scope lists the identity provider, Plane edition, redirect URIs, attribute mapping and role mapping
- Scope states whether seats follow paid roles assigned in your identity provider or are managed manually in Plane
How we build
- Configure the SAML or OIDC application in your identity provider and test sign-in against a non-production Plane workspace
- Set up attribute and group mapping so user roles in Plane match the roles defined in your directory
- Where LDAP is in scope, confirm the Enterprise feature set on your Plane plan before connecting the directory
How we hand over
- Written runbook covering protocol settings, certificate or client secret locations, and rotation steps
- Test evidence showing successful sign-in, denied access for unmapped users and role assignment results
- Admin walkthrough for adding, removing and changing seat roles, including the steps for offboarding a user
How we support
- Retainer support can be scoped to cover identity configuration changes, certificate renewals and sign-in troubleshooting after go-live
- Re-test sign-in after each Plane upgrade, since the Community and Commercial editions follow separate release cycles
- Confirm with Plane whether any SSO setting changes between releases before you upgrade a production workspace

