Every new application raises the same question: how do user accounts get in and how do they get out again? Instead of building a dedicated connector for every app, at Univention we rely on SCIM (System for Cross-domain Identity Management), an open standard for the automated provisioning of accounts. As a first real-world test, we connected the Nubus SCIM Client to the secure messenger Wire and successfully synced a test user over a standard protocol, without a dedicated Wire connector. For now, this is an early proof of concept: the SCIM Client is still labelled experimental and is available for Nubus for Kubernetes. But it is one that shows the direction: connecting new apps through documented configuration, rather than waiting on a custom build for each app.
Table of Contents
Why Integrations Often Become the Bottleneck Today
In many IT landscapes, the answer so far has been a dedicated connector, a dedicated custom build, a dedicated maintenance burden. Per app. Every single time.
That scales poorly. With every application, the number of one-off solutions grows and with it the risk of orphaned accounts, stale data, and inconsistent permissions. This is exactly where the idea behind this article comes in: connect applications through open, documented standards, not through custom code for every individual case.
That is why, at Univention, we are investing in support for SCIM (System for Cross-domain Identity Management). As a first practical test of this approach, we connected the Nubus SCIM Client to Wire, a secure messaging platform and looked at what a standards-based integration actually feels like in practice.
What Is SCIM and Why Is It the Right Foundation?
SCIM is an open standard for provisioning identity data. Across vendors, it describes how events such as account creation, name changes, or deletions are transferred automatically between systems – in time, including groups and permissions.
The key point: SCIM is not tied to a single application. If a target application speaks SCIM, it can in principle be connected over the same documented path, instead of through an app-specific connector. This makes SCIM the logical building block for User Lifecycle Management: accounts are kept up to date not only conveniently, but also securely, because sources of error and manual steps fall away.
In Nubus, SCIM thus complements the open standards already in place. Nubus supports OIDC, SAML, LDAP, SCIM, REST, and Kerberos and can therefore connect virtually any modern or legacy application. SCIM is the building block for the push mechanism: accounts are actively provisioned into the target systems, rather than merely queried there.
The Field Test: Connecting Nubus and Wire Via SCIM
For the first real-world test, we connected the Nubus SCIM Client to the Wire SCIM API. For this, Wire provides a dedicated area for automated user management in its team settings, where the SCIM URL and a bearer token can be found – the two building blocks the SCIM Client needs for the connection.
We set up the connection based on the SCIM Client chapter of the Nubus for Kubernetes Operation Manual, plus one additional option that sets which field becomes the username. The result: a test user was successfully synced between the two systems. Basic account provisioning between Nubus and Wire therefore works over a standard protocol, without any code written specifically for Wire.
One practical detail is especially relevant here: Wire requires a globally unique username per user. The SCIM Client solves this via a stable, unique identifier (the univentionObjectIdentifier field from the Univention Directory Manager), which is passed to Wire as the unique username. This way, target systems with strict uniqueness requirements are handled correctly.

An Honest Assessment: What Works Today and What Doesn’t
This integration is at an early stage. Here is the current state at a glance:
- What works today: creating, updating and deleting users, mapped through a stable, unique identifier. This correctly handles target systems like Wire that require globally unique usernames. If a change cannot be delivered, it is not lost: the client retries temporary errors and keeps permanent failures for administrators to review.
- What is not part of this stage yet: group synchronization, role and permission synchronization, and configurable attribute mapping. The SCIM Client is currently labelled experimental and is available for Nubus for Kubernetes.
This is deliberately not a finished, marketed feature built just for Wire. It is a proof point for something bigger: technical admins should be able to connect the applications they need through open standards and documented configuration, instead of waiting for a bespoke integration for every new app.
What Comes Next
We are currently building out support for attribute mapping in a more general, reusable way. And we plan to test the same approach against additional SCIM-compatible applications step by step. The guiding idea stays the same: one path, many apps instead of many one-off paths for many apps.
How SCIM fits into the bigger picture of integrations over open standards, and which architectural questions matter along the way, is what we explore in the follow-up article “SCIM as a tool for integrations.”
Conclusion and next step
The Wire test shows in miniature what matters at scale: integrations over an open standard instead of custom code. For now it is an early proof of concept with user provisioning, but one that makes the direction clear.
The technical setup details, installation, all configuration options, and current limitations, can be found in the Nubus for Kubernetes – Operation Manual, SCIM Client section.