H· Hawiyati Documentation

Product Overview

Hawiyati (هويتي — "My Identity") is an on-premises Identity and Access Management platform for organizations that require full sovereignty over their identity infrastructure. It delivers enterprise-grade SSO, adaptive MFA, SCIM provisioning, KYC document verification, and compliance-grade audit logging — all running inside your own network.

Hawiyati (هويتي — "My Identity") is an on-premises Identity and Access Management platform for organizations that require full sovereignty over their identity infrastructure. It delivers enterprise-grade SSO, adaptive MFA, SCIM provisioning, KYC document verification, and compliance-grade audit logging — all running inside your own network.

What is Hawiyati?

Hawiyati (هويتي — "My Identity") is an on-premises Identity and Access Management platform for organizations that require full sovereignty over their identity infrastructure. It delivers enterprise-grade SSO, adaptive MFA, SCIM provisioning, KYC document verification, and compliance-grade audit logging — all running inside your own network.

At its core, Hawiyati is a federation hub: users authenticate once, and Hawiyati issues signed SAML assertions or OIDC tokens to every connected application. Authentication policy, multi-factor enforcement, adaptive risk scoring, and session lifecycle are all centralized in the platform, so individual applications never need to implement their own authentication.

Data sovereignty by design

ConstraintHow it is enforced
No external runtime callsAuthentication flows make no outbound HTTP calls to third-party services. All resources are served locally.
No telemetryThe platform does not phone home, transmit usage data, or contact vendor infrastructure during operation.
Credentials never in plaintext at restPasswords: Argon2id. TOTP secrets: AES-256-GCM. FIDO2: public key only stored. Recovery codes: Argon2id hash, shown once then discarded.
No secrets in audit eventsPasswords, OTP values, and tokens are explicitly excluded from all audit event fields.
Bundled UI assetsFonts, icons, and frontend assets are served locally. No CDN or Google Fonts dependency at runtime.
Internet-isolated operationAfter initial installation, the platform operates fully without internet access. Geolocation data is loaded locally.

Why On-Premises?

Cloud-hosted identity platforms (Okta, Entra ID, Ping Cloud) route authentication events and user data through external infrastructure. For organizations subject to local data sovereignty laws, national security requirements, or network isolation policies, this is not acceptable.

Hawiyati runs entirely inside the customer's network. It has no phone-home behavior, no external API calls at runtime, no CDN-hosted assets, and no requirement for internet connectivity during operation. This makes it suitable for:

AudienceKey requirement met
Government agenciesSovereign deployment with no external data flows. Supports Arabic-locale UI. Meets local data residency requirements.
Financial institutionsCompliance-grade audit trail, MFA enforcement, adaptive access by network zone and risk score, LDAP/AD integration.
Healthcare organizationsRole-based access control, session management, consent tracking, exportable audit logs for regulatory review.
Enterprise IT teamsCentralized SSO for all SAML 2.0 and OIDC applications, SCIM provisioning, user lifecycle management.
Security operationsReal-time risk signals, login activity monitoring, device tracking, SIEM-compatible audit output.

Current Maturity

Pre-production platform

Hawiyati has a working core suitable for proof-of-concept and pilot deployments. Some items require hardening before production use. Review the tables below before committing to a production deployment timeline.

Complete and functional

AreaStatus
SSO (SAML 2.0 and OIDC) with working SP demos for each protocolDone
Full MFA stack: password, TOTP, email OTP, SMS OTP, FIDO2/passkeysDone
Adaptive access engine with risk scoring and enforcementDone
LDAP/AD bind and syncDone
SCIM 2.0 inbound provisioning APIDone
Self-service account portal (profile, security, devices, sessions, activity, privacy)Done
Admin console — users, groups, applications, policies, audit logsDone
Structured audit log with database storage and SIEM-compatible outputDone
KYC document upload and admin reviewDone

Requires hardening before production

ItemPhase
gRPC mutual TLS between internal services (currently plain gRPC in dev)Phase 4
Secrets management integration (HashiCorp Vault; currently config-file secrets)Phase 4
Automated account recovery flowsPhase 4
Full automated deployment pipeline and backup automationPhase 4
Security testing and formal vulnerability assessmentPhase 4
Gateway authentication (JWT / session cookie validation at the edge)Phase 4
Cryptographic library migration (OpenSAML 5 + Nimbus JOSE+JWT + BouncyCastle FIPS)Phase 4

Server Requirements

ResourceMinimum (Pilot)Recommended
CPU4 vCPU8 vCPU
RAM8 GB16 GB
Disk50 GB SSD200 GB SSD
OSRHEL 8+, Ubuntu 22+RHEL 9
JavaJava 21 (OpenJDK)Java 25 (OpenJDK)
DatabasePostgreSQL 14+PostgreSQL 16
CacheRedis 7+Valkey 8

For high-availability deployments, add a PostgreSQL streaming replication standby and a Redis Sentinel cluster. See the Operations Guide for details.


Platform Architecture

Hawiyati is a microservices platform. Each service is a self-contained Spring Boot JAR deployed on customer-managed infrastructure. Services communicate internally via gRPC. External browser and API traffic enters through an HTTP gateway.

Hawiyati IAM Platform — Component Architecture HAWIYATI IAM PLATFORM — COMPONENT ARCHITECTURE Spring Boot 3.5 · Java 25 · gRPC EXTERNAL ACTORS ENTRY LAYER & FEDERATION HTTPS · SAML 2.0 · OIDC · WebAuthn PLATFORM SERVICES HTTPS internal · gRPC DATA & INFRASTRUCTURE JDBC · Redis pub/sub · gRPC User Browser Browser · Mobile App Administrator Admin Console SAML Service Provider SAML 2.0 OIDC Relying Party OIDC · OAuth 2.0 SCIM Client HR System · Directory hawiyati-gateway Spring Cloud Gateway · :8080 Routing · TLS termination hawiyati-http-server IdP Login · MFA · FIDO2 · :8085 SAML ACS · OIDC callback · Account BFF hawiyati-federation SAML 2.0 · OIDC · :8087 Assertion & token issuance · Policy hawiyati-admin Admin Console · :8095 · WebFlux hawiyati-account Account Portal · :8096 · BFF/OIDC hawiyati-scim SCIM 2.0 API · :8098 hawiyati-session · :9004 hawiyati-cache · :9003 hawiyati-infra · :9002 PostgreSQL hawiyati · hawiyati_identity Redis / Valkey Sessions · Cache · Rate limits Audit & Logs CEF Syslog · OTel · SIEM PKI & Keystore SAML · OIDC · mkcert TLS External Actor External System Entry / Federation Platform Service gRPC Service Data Store

The sections below cover the platform's architecture zones and service topology. For deployment details and per-module configuration, see the Implementation Guide.

Design principles

PrincipleWhat it means
Sovereign by designNo runtime component makes outbound calls to external services. All assets are bundled locally. The platform operates with no internet connectivity after installation.
Defense in depthIdentity data and configuration data live in separate database schemas and can be on different physical servers. Browser-facing services are distinct from internal gRPC services. Authentication logic is separated from protocol encoding.
Stateless federation layerAuthentication state runs on the IdP. Sessions are in Redis with an opaque token issued to the browser. The federation layer is stateless — it reads the session, builds the assertion or token, and discards nothing.
Pluggable auth methodsThe authenticator pipeline is a registry of named providers. The login flow selects which providers to invoke based on the authentication policy bound to the target application.

Service Topology

The diagram below shows how services relate across the network — from external users through the gateway, HTTP services, internal gRPC services, and down to the data layer.

Hawiyati application architecture showing actors, access, identity, administration, platform services, and data layers
Application architecture and trust boundaries. The light architectural palette is the visual standard for all documentation workflows.
External / Users
Browser
End users
SAML SP
Applications
OIDC Client
Applications
SCIM Client
HR / IGA systems
HTTPS↓
Edge / Gateway
hawiyati-gateway:8080 · Spring Cloud Gateway · routing only
HTTPS↓ routes by path prefix HTTPS (direct)↓
HTTP Services
hawiyati-http-server:8085 · IdP, SAML, Login
hawiyati-federation:8087 · OIDC endpoints
hawiyati-admin:8095 · Admin console
hawiyati-account:8096 · Self-service portal
hawiyati-scim:8098 · SCIM 2.0 API
gRPC↓
Internal gRPC Services
hawiyati-infraSP Registry & Config
hawiyati-sessionSession Manager
hawiyati-cacheRedis Facade
in-process (library JARs)
Shared Libraries (in-process)
hawiyati-persistenceJPA / Flyway
hawiyati-auditCEF / OTel / Prometheus
hawiyati-saml-federationSAML 2.0 stack
hawiyati-openid-federationOIDC stack
hawiyati-utilsPKI / Crypto
JDBC↓ Redis Protocol↓
Data Stores
PostgreSQL:5432 · hawiyati_config (24 tables)
hawiyati_identity (13 tables)
Redis / Valkey:6379 · Sessions · OTP · Rate limits
SP config cache (pub/sub invalidation)
Gateway / Edge
HTTP Service
gRPC Service
Shared Library
Data Store

Trust Boundary View

Services are grouped into four trust zones. Network firewall rules should enforce these boundaries: only the gateway and direct-access services are externally reachable; gRPC and data services are internal-only.

External Zone — Customer Network / Internet
Browser (End Users)
SAML SP Applications
OIDC Clients
SCIM Clients (HR/IGA)
Application Zone — Hawiyati HTTP Services
hawiyati-gateway :8080
hawiyati-http-server :8085
hawiyati-federation :8087
hawiyati-admin :8095
hawiyati-account :8096
hawiyati-scim :8098
Internal gRPC Zone — Service-to-Service Only
hawiyati-infra (gRPC)
hawiyati-session (gRPC)
hawiyati-cache (gRPC)
Data Zone — Restricted Access
PostgreSQL :5432
Redis / Valkey :6379

Service Map

HTTP-facing services

ServicePortRole
hawiyati-gateway8080Edge router — Spring Cloud Gateway. Routes inbound requests to downstream services.
hawiyati-http-server8085IdP browser entry point. Hosts login, MFA, registration, and password-reset flows. Handles SAML SSO and ACS endpoints.
hawiyati-federation8087Federation orchestrator. Hosts all OIDC endpoints (/oidc/authorize, /oidc/token, /oidc/userinfo, /oidc/jwks, /.well-known/openid-configuration).
hawiyati-admin8095Administrator console. Web UI and REST API for managing users, applications, policies, audit logs, and settings. Role-gated.
hawiyati-account8096End-user self-service portal (BFF pattern). Users manage profile, security factors, devices, sessions, activity log, and privacy settings.
hawiyati-scim8098SCIM 2.0 inbound provisioning API. External HR systems or IGA platforms push user records here using Bearer token auth.

Internal gRPC services

ServiceRole
hawiyati-infraSP registry and configuration service. Loads SP registry from sp-registry.yml on first boot, then persists to the database. Other services look up SP configs and signing keys here.
hawiyati-sessionSession lifecycle manager. Creates, reads, and destroys sessions in Redis. Centralizes session serialization across all services.
hawiyati-cacheRedis cache facade. Provides a consistent caching interface for rate-limit counters, OTP state, and SP config caching.

Shared libraries (not services)

LibraryRole
hawiyati-persistenceJPA entities, Flyway migrations (current head: V62), and EncryptionService (AES-256-GCM).
hawiyati-auditStructured audit event writer — NDJSON to disk, CEF/syslog forwarder, Prometheus counters, OTel traces, JpaAuditEventSink for the admin console.
hawiyati-directoryAD/LDAP integration — pass-through bind authentication and periodic directory sync.
hawiyati-saml-federationCustom SAML 2.0 implementation: AuthnRequest/Response encoding, metadata, RSA-SHA256 signing, SLO chain.
hawiyati-openid-federationCustom OIDC implementation: Authorization Code flow, PKCE, RS256 ID token, claims mapping, token response.

Network Topology

External users / Service providers
        │
        ▼
┌──────────────────────────────────────┐
│  hawiyati-gateway  :8080             │   Edge — routing only
│  Spring Cloud Gateway                │
└───────┬──────────────────────────────┘
        │ routes by path prefix
        ├──▶ hawiyati-http-server  :8085   IdP browser flows, SAML endpoints
        └──▶ hawiyati-federation   :8087   OIDC endpoints, discovery

┌─────────────────────────────────────────────────────────┐
│  Direct browser access (not through gateway)            │
│  hawiyati-admin   :8095  — admin console                │
│  hawiyati-account :8096  — self-service portal          │
│  hawiyati-scim    :8098  — SCIM provisioning API        │
└─────────────────────────────────────────────────────────┘

Internal gRPC calls (service-to-service only)
  http-server  ──gRPC──▶  federation  (SSO build)
  http-server  ──gRPC──▶  session     (session R/W)
  http-server  ──gRPC──▶  infra       (SP lookup)
  federation   ──gRPC──▶  infra       (SP lookup, keys)
  federation   ──gRPC──▶  session     (session validation)
  admin        ──gRPC──▶  infra       (SP registry CRUD)

Shared infrastructure
  All services ──JDBC──▶  PostgreSQL :5432
  All services ──TCP───▶  Redis/Valkey :6379
Current state: gRPC channels run in plaintext

Mutual TLS for inter-service gRPC channels is planned for Phase 4. In the current release, internal gRPC traffic should be restricted to a trusted network segment.


Trust Zones

Zone A — Public internet / customer network
  ├── Browser users (employees, end users)
  └── Service providers (SAML SPs, OIDC relying parties, SCIM clients)

Zone B — Hawiyati HTTP services (browser-accessible)
  ├── hawiyati-http-server  (login, SAML ACS)
  ├── hawiyati-federation   (OIDC endpoints, discovery)
  ├── hawiyati-admin        (admin console — network-restrict this)
  ├── hawiyati-account      (self-service portal)
  └── hawiyati-scim         (provisioning API)

Zone C — Internal gRPC services (no public exposure)
  ├── hawiyati-infra
  ├── hawiyati-session
  └── hawiyati-cache

Zone D — Data tier (no public exposure)
  ├── PostgreSQL
  └── Redis / Valkey

Recommended network controls:

  • The admin console (:8095) must be restricted to the corporate management network or VPN — not public-facing.
  • The SCIM API (:8098) should only be reachable from provisioning sources (HR system, IGA platform).
  • Zones C and D must not be reachable from Zone A. Firewall rules should limit PostgreSQL and Redis access to the Hawiyati service hosts only.
  • All public endpoints must be served over TLS. Production deployments should use an internal CA or a trusted public CA.

Data Stores

PostgreSQL — source of truth

PostgreSQL holds all durable identity and configuration state, partitioned into two schemas:

hawiyati_config schema — IdP configuration (24 tables)

Application (SP) registrations, authentication policies, network zones, admin operator accounts, LDAP configurations, SCIM tokens, system settings, and audit event records.

CategoryTables
Application registryservice_providers, sp_saml_config, sp_oidc_config, sp_oidc_redirect_uris, sp_oidc_scopes, sp_auth_methods
Authentication policiesauth_policies, policy_rules, rule_conditions, rule_actions, rule_action_methods, network_zones, network_zone_cidrs
Administrationadmin_operators, admin_roles, admin_totp_credentials, admin_recovery_codes
Directory integrationldap_directories, external_sql_stores, user_store_config
Systeminstance_settings, scim_tokens, audit_events, registration_policy

hawiyati_identity schema — end-user directory (13+ tables)

CategoryTables
Users and groupsusers, user_groups, user_group_members
Credentialsuser_totp_credentials, user_recovery_codes, user_fido2_credentials
Session and risklogin_attempts, user_known_devices, user_auth_geo
Self-service and governanceconsent_record, user_unique_attribute_value, invitation_tokens, user_kyc_submissions, kyc_profiles

Schema isolation: The identity schema can be placed on a physically separate PostgreSQL server. Schema evolution is managed by Flyway (embedded in hawiyati-persistence). Current head: V62.

Redis / Valkey — transient state only

Key spaceContents
IdP sessionsAuthenticated user sessions — user ID, MFA state, active SP sessions, login flow progress
OIDC/SAML in-flightAuthorization request parameters, stored between the authorization request and code exchange
OTP codesShort-lived codes for email and SMS OTP (with TTL)
Rate-limit countersSliding-window counters for SMS OTP sends, login attempts, and API endpoints
SP config cacheCached SP registry entries — invalidated via Redis pub/sub channel sp-config:invalidate

Redis is safe to flush and restart. Sessions will be lost (users must re-authenticate), but no permanent identity data is affected. Hawiyati is compatible with both Redis 7+ and Valkey 7+.


Encryption at Rest

All sensitive fields are encrypted at rest using AES-256-GCM via EncryptionService. The encryption key is read from the HAWIYATI_ENCRYPTION_KEY environment variable at startup.

FieldTableMethod
TOTP secretsuser_totp_credentialsAES-256-GCM (encrypted, recoverable in memory)
LDAP bind passwordsldap_directoriesAES-256-GCM
SMTP passwordinstance_settingsAES-256-GCM
Identity DB connection passwordidentity_db_connectionAES-256-GCM
OIDC signing keyssp_oidc_configAES-256-GCM
User passwordsusersArgon2id (one-way hash)
Admin operator passwordsadmin_operatorsArgon2id (one-way hash)
Recovery codesuser_recovery_codesArgon2id (plaintext shown once at generation only)
SCIM tokensscim_tokensSHA-256 (raw token shown once at generation only)

Identity Model

Identity lifecycle from an authoritative source through deletion
Common identity lifecycle with verification, activation, maintenance, deactivation, retention, and deletion gates.

Entity types

EntitySchemaNotes
End userhawiyati_identity.usersIdentified by a stable UUID. Attributes: username, email, phone, name, active state, source type, custom attributes. Created via admin CRUD, self-service registration, LDAP JIT, SCIM push, or SQL sync.
Admin operatorhawiyati_config.admin_operatorsSeparate from end users. Authenticate to the admin console only. Governed by admin RBAC roles.
Grouphawiyati_identity.user_groupsLocal or LDAP-sourced. Used by policy conditions and admin assignment workflows.
Devicehawiyati_identity.user_known_devicesCreated by the adaptive risk engine when a new device fingerprint is seen. Users can rename or revoke devices in the account portal. Revocation is soft.
Service Providerhawiyati_config.service_providersA SAML SP or OIDC relying party registered in the admin console. Has its own attribute release policy and authentication policy binding.

User Store Modes

Hawiyati operates with one active user store at a time. The active mode is set in Admin → Settings → User Stores.

ModeAuthentication behavior
LocalUsers are created and managed inside Hawiyati. Passwords are hashed with Argon2id. All MFA methods available.
LDAP / Active DirectoryPassword is a pass-through LDAP bind against the configured directory server. On first successful bind, a shadow user record is created just-in-time. Periodic sync imports attributes and group memberships.
SCIMUsers are provisioned into the local database via the SCIM API. Authentication then uses the local credential (provisioning tools typically set an initial password or trigger a password-reset flow).
External SQLHawiyati reads users from a customer-managed relational database. Passwords are verified against the stored hash using the customer's configured algorithm. Read-only bridge — user data is not copied.

Authentication Methods

🔑
Password
pwd
Local Argon2id hash or LDAP pass-through bind. The raw password is never stored, logged, or included in audit events.
KnowledgeAAL1
📱
TOTP Authenticator
totp
RFC 6238 — 6-digit codes, 30-second window, ±1 clock skew tolerance. TOTP secret stored AES-256-GCM encrypted. Replay protection enforced per 30-second window.
PossessionAAL2
✉️
Email OTP
email_otp
6-digit code sent to registered email. Valid 5 minutes, max 5 attempts. Server stores only HMAC-SHA256. Anti-enumeration: identical form shown regardless of whether user has an email registered.
PossessionAAL2
💬
SMS OTP
sms_otp
6-digit code sent via configurable HTTP SMS gateway. Rate-limited per phone number (SHA-256 keyed bucket — phone number never in plaintext in Redis). Anti-enumeration: same form regardless of enrollment.
PossessionAAL2
🔐
FIDO2 / Passkey
fido2
WebAuthn public-key authentication. Private key never leaves the device. Phishing-resistant — credential is bound to the relying party origin. Hawiyati stores the public key only. Signature counter enforced.
Possession+InherenceAAL2Phishing-resistant
🛡️
Recovery Code
recovery_code
One-time backup codes generated at MFA enrollment. Shown to the user exactly once — stored thereafter only as Argon2id hashes. Permanently invalidated after use. For account recovery when MFA device is lost.
Backup

MFA Login Flow

Authentication policy and MFA step-up decision flow
Application policy determines whether primary authentication is sufficient or stronger authentication is required.

Every login begins when the user's browser follows a SAML SSO request or OIDC authorization redirect to Hawiyati's IdP endpoint. The IdP drives the user through a sequence of authentication steps determined by the authentication policy bound to the target application.

How the step sequence is built

Policy resultStep sequence
ALLOWPassword only (pwd).
MFA_REQUIRED with specific factorsPassword, then each required factor in order (e.g. pwd → totp). User cannot switch methods.
MFA_REQUIRED with no specific factorsPassword, then a method picker showing all MFA methods the user has enrolled.
DENYA denial screen — no credentials are accepted.

Login flow state

The login engine maintains a LoginFlowState in the user's IdP session for the duration of authentication. It holds: provider sequence, step index, username, AMR list (methods successfully completed so far), LoA reached, and per-provider scratch state (OTP hash, FIDO2 challenge). The flow is complete when the step index passes the end of the sequence.

SSO fast path

If the user's IdP session is already authenticated when a new SSO request arrives, authentication steps execute without showing the login page. The user is redirected through the SP with a new assertion, invisible to them.


Assurance Levels

Hawiyati tracks the highest authentication assurance level (AAL) reached during login. This value is available in the OIDC acr claim and SAML AuthnContextClassRef.

LevelNameAchieved by
AAL1Single factorPassword only (Argon2id or LDAP pass-through). Minimum for any authenticated session.
AAL2Multi-factor or phishing-resistant single factorPassword + any MFA method (TOTP, email OTP, SMS OTP), or FIDO2 alone. FIDO2 also satisfies phishing-resistance.

The amr list in the session (and the OIDC token) records every method used, in order (e.g. ["pwd", "totp"]). Applications that need to verify the exact methods used should inspect amr rather than relying on acr alone.

For identity proofing assurance levels (L0–L4 per NIST SP 800-63A-4), see the Registration & KYC guide.


SAML 2.0 and OIDC Request Flows

SAML 2.0 SP-initiated SSO

1. User visits the application (SP)
2. SP builds a SAML AuthnRequest, redirects browser to
   GET /saml/sso on hawiyati-http-server (HTTP-Redirect binding)
3. http-server decodes the AuthnRequest, stores it in the IdP session,
   redirects to /idp/login
4. User enters credentials + completes MFA on hawiyati-http-server
5. http-server calls hawiyati-federation over gRPC to build the
   signed SAML Response + Assertion (RSA-SHA256, Assertion element)
6. http-server renders an auto-POST HTML form; browser POSTs
   SAMLResponse to the SP's Assertion Consumer Service (ACS) URL
7. SP validates the signature, audience, and conditions;
   establishes its own session

Single Logout: Hawiyati chains logout to every SP the user visited in that IdP session. The browser is redirected SP-to-SP, each clearing its cookie and sending a LogoutResponse back to Hawiyati.

OIDC Authorization Code flow (with PKCE)

1. User clicks "Sign in" on the application (relying party / RP)
2. RP generates state, nonce, and PKCE pair; redirects browser to
   GET /oidc/authorize on hawiyati-federation
3. federation validates the request (client_id, redirect_uri, scope),
   stores the OIDC session, redirects to /idp/login
4. User authenticates + completes MFA on hawiyati-http-server
5. http-server calls federation over gRPC; federation generates an
   authorization code (valid 60 seconds), redirects browser back to
   the RP's redirect_uri with ?code=...&state=...
6. RP's server sends a back-channel POST /oidc/token with
   code + code_verifier to hawiyati-federation
7. federation validates PKCE, client credentials, and code;
   issues a signed RS256 ID Token + access token
8. RP validates ID Token (signature, iss, aud, exp, nonce);
   uses sub as the stable user identifier

Feature Matrix

Authentication and MFA

CapabilityStatus
Password authentication (local Argon2id)Available
Password authentication (LDAP/AD pass-through)Available
TOTP authenticator (RFC 6238, encrypted at rest)Available
Email OTPAvailable
SMS OTP (configurable HTTP gateway)Available
FIDO2 / WebAuthn / PasskeysAvailable
Recovery codes (hashed, one-time display)Available
Password-less loginRoadmap

Application Federation

CapabilityStatus
SAML 2.0 Identity Provider (SP-initiated and IdP-initiated)Available
OpenID Connect Identity Provider (Authorization Code + PKCE)Available
Per-application authentication policyAvailable
SAML attribute mappingAvailable
OIDC scope and claims mappingAvailable
Front-channel / back-channel logoutPartial
WS-FederationRoadmap

User Lifecycle and Provisioning

CapabilityStatus
Local user directoryAvailable
LDAP / Active Directory integration (bind + sync)Available
SCIM 2.0 inbound provisioning APIAvailable
Admin-managed user lifecycle (create, edit, reset, delete)Available
Self-service registrationAvailable
Self-service profile, password, MFA, devices, sessionsAvailable
KYC document upload and admin reviewAvailable
External SQL user store (read-only bridge)Partial
SCIM outbound provisioningRoadmap

Adaptive Access and Policies

CapabilityStatus
Per-application authentication policy with first-match rule evaluationAvailable
Group-based policy conditionsAvailable
Time-of-day and network zone conditionsAvailable
New-device detectionAvailable
Login velocity anomaly detectionAvailable
GeoIP-based risk scoringAvailable
IP reputation risk signalsAvailable
Enforcement modes: allow, step-up, blockAvailable

Administration and Audit

CapabilityStatus
Web-based admin consoleAvailable
User and group managementAvailable
Application (SP) registration — SAML and OIDCAvailable
Structured audit log (database-backed, searchable)Available
Audit log export to CSVAvailable
CEF / syslog audit outputAvailable
Prometheus metricsAvailable
OpenTelemetry tracingAvailable
Role-based admin access controlAvailable