Skip to main content
This feature plays a key role in ensuring that the correct project configuration is executed, managing how processes interact with specific builds, and controlling how changes propagate through environments. The active policy determines which project version is currently “live” and dictates how updates and new builds are adopted.
Active Policy
Active Policy supports both global policies that apply to all users and specific policy overrides for individual users or roles, allowing independent testing of different builds or branches.

Key concepts

Active build

  • The active build is the currently selected version of a project that is deployed in the runtime environment. It is the version that all process executions will reference when initiated.
  • While a global policy applies to all users by default, individual policy overrides can specify different active builds for specific users or roles.

Policy types

  • Latest on Branch: Configures the project to run the latest version on a specific branch. This is useful for environments like development or testing, where ongoing changes need to be reflected in real-time.
  • Build: Points to a specific, committed build version of the project. This policy ensures that no unexpected updates are introduced and is typically used for UAT and Production environments.

Policy hierarchy

  • Global Policy: The default policy that applies to all users unless overridden.
  • Policy Overrides: User-specific or role-specific policies that take precedence over the global policy for targeted users.
  • Policy overrides enable independent testing of different builds or branches without affecting other users.

Version control and flexibility

  • Active Policy provides flexibility by allowing different users to work with different build versions simultaneously.
  • By managing both global policies and overrides, you control which changes go live for which users and when, allowing for seamless testing and controlled rollouts.

Global policy

The Global Policy section defines the default active policy that applies to all users unless specifically overridden by individual policy overrides.
1

Navigate to Active Policy

Go to your project’s Runtime Settings and select the Active Policy tab.
2

Configure Global Policy

In the Global Policy section, choose your policy type:
  • Latest on Branch: Always use the latest version on the selected branch
  • Build: Use a specific committed build version
Select the appropriate branch and build version based on your policy choice.
3

Update Policy

Click Update to apply the global policy changes.
The policy takes effect immediately for all users without specific overrides.

Policy overrides

Policy Overrides allow you to define specific active policies for individual users or roles, enabling independent testing of different builds or branches without affecting the global policy.
Define policies for specific users or roles to simulate conditions and test branch behavior independently from the global policy.

Managing policy overrides

The Policy Overrides section provides comprehensive tools for creating, managing, and monitoring user-specific and role-specific active policies.

Override table structure

The policy overrides are displayed in a table with the following columns:
  • Override Type: Specifies whether the override applies to a Username or Role.
  • Applies To: Shows the specific username (for User overrides) or role name (for Role overrides) that this policy applies to.
  • Policy: Specifies the policy type to use for the override.
  • Branch/Build Version: Specifies the branch or build version to use for the override.
  • Priority: Specifies the priority of the override.
  • Status: Shows whether the override is Active or Inactive.

Search and filter

Use the search functionality to quickly locate specific overrides:
  • Search by Username: Enter a username to filter overrides for specific users
  • Search by Role: Enter a role name to filter overrides for specific roles
  • The search filters the table in real-time as you type
1

Add New Override

Click the Add button (+ icon) to create a new policy override.
2

Configure Override Type

Select whether the override applies to a Username or Role:
  • Username: Choose a specific user from the dropdown
  • Role: Select a role from the available options
3

Set Policy Configuration

Choose the policy type:
  • Latest on Branch: Select the branch to use
  • Build: Choose a specific build version
4

Set Priority

Assign a priority number to handle conflicts when multiple overrides could apply.
Priority is mandatory for role-based overrides and must be unique across all role overrides.
Lower numbers = higher priority. Use priority 0 for the most critical overrides.
5

Enable Override

Check Enable this override to activate it immediately, or leave unchecked to create it in an inactive state.
6

Create Override

Click Create Override to save the new policy override.
The override appears in the table and takes effect immediately if enabled.

Override management actions

Each override in the table provides several management options: Edit Override
  • Click the edit icon to modify override settings
  • Update policy type, target build/branch, or priority
  • Changes take effect immediately upon saving
Contextual Menu Actions
  • Activate/Deactivate: Toggle the override on or off without deleting it
  • Delete: Permanently remove the override
Deleting an override immediately reverts affected users to the global policy. Ensure this change is intentional.

Key features

Environment-specific control

  • Each environment can have its own global policy and set of policy overrides
  • Control what version of the project runs for different user groups at each stage of development

User-specific testing

  • Policy overrides enable individual users or roles to test different builds independently
  • Developers can work with different versions simultaneously without conflicts
  • QA teams can test specific builds while production users remain on stable versions

Priority-based resolution

  • When multiple overrides could apply, priority determines which takes precedence
  • Fine-grained control over policy application in complex scenarios
  • Clear hierarchy: User overrides > Role overrides > Global policy

Rollback capability

  • Easily revert to previous builds by updating the global policy or specific overrides
  • Quick rollback minimizes disruption and maintains system stability
  • Independent rollback for specific users without affecting others

Branch-specific management

  • Support for branch-based policies in both global settings and overrides
  • Parallel development with different active branches for different user groups
  • Flexible testing scenarios across multiple development streams

Benefits

  • Controlled Rollouts: Gradual deployment to specific users or roles before wider release
  • Independent Testing: Users can test different builds simultaneously without conflicts
  • Enhanced Stability: Risk mitigation through targeted deployment and easy rollback
  • Flexible Development: Support for parallel development streams and testing scenarios
  • User-Centric Control: Granular policy management at the user and role level
  • Priority Management: Clear resolution when multiple policies could apply

Permissions and access control

Active Policy management requires appropriate permissions to ensure secure and controlled access to policy configuration.
Access to Active Policy settings should be strictly controlled as changes can affect production environments and user experience.

Required permissions

  • View Active Policy: Required to view current global policy and policy overrides
  • Manage Global Policy: Required to modify the global active policy settings
  • Manage Policy Overrides: Required to create, edit, activate/deactivate, and delete policy overrides
  • Admin Access: Full access to all active policy features and settings

Permission enforcement

  • Unauthorized actions are blocked with clear denial messages
  • All policy changes are audited with user identification and timestamps
  • Role-based access ensures users can only perform actions within their authorization level
Contact your system administrator if you need additional permissions to manage active policies.

Technical details

Policy resolution hierarchy

When a user accesses the runtime environment, the system resolves their active policy using this hierarchy:
  1. User-specific overrides (highest priority)
  2. Role-specific overrides (if no user override exists)
  3. Global policy (default fallback)

Priority-based override resolution

  • When multiple role overrides could apply to a user, the override with the lowest priority number takes precedence
  • User-specific overrides always take precedence over role-based overrides regardless of priority
  • Priority numbers must be unique for role-based overrides and are mandatory
  • Priority is particularly important when users are assigned multiple roles, ensuring deterministic policy resolution
  • Priority numbers help resolve conflicts in complex role hierarchies
In scenarios where a user has multiple roles (e.g., DEVELOPER and QA_TESTER), the system uses the role override with the lowest priority number to determine their active policy.

Project context and resource references

  • The active policy system determines how resource references are handled during process execution
  • At runtime, the system identifies the active build based on the resolved policy for each user
  • Ensures correct resource definitions are used based on user-specific or global policies

Metadata and versioning

  • Each policy (global and overrides) includes comprehensive metadata:
    • Build ID and version tags
    • Branch references and commit information
    • User/role assignments and priority settings
    • Creation and modification timestamps

Audit and monitoring

  • All policy changes are logged with detailed audit information:
    • User performing the action
    • Timestamp of the change
    • Before and after values
    • Action type (create, update, delete, activate, deactivate)
  • Audit logs are accessible to authorized users for compliance and troubleshooting

Storage and management

  • Active policies and overrides are stored separately from build data
  • Policy changes don’t affect build integrity
  • Efficient policy resolution at runtime with minimal performance impact
  • Scalable architecture supports complex override scenarios

Example use cases

Scenario 1: Feature testing with user overrides

A development team needs to test a new feature without affecting production users:
1

Set Global Policy

Configure the global policy to use the stable production build (e.g., Build v2.1.0).
2

Create User Override

Create a policy override for the development team:
  • Override Type: Role
  • Applies To: DEVELOPER
  • Policy: Latest on Branch
  • Branch: feature/new-payment-flow
  • Priority: 1
3

Test Independently

Developers can now test the new feature while production users continue using the stable build.
No impact on production users during feature development and testing.

Scenario 2: Gradual rollout with priority management

Rolling out a new version to different user groups:
1

QA Testing Override

Create high-priority override for QA team:
  • Role: QA_TESTER
  • Policy: Build v2.2.0-rc1
  • Priority: 0 (highest)
2

Beta User Override

Create override for beta users:
  • Role: BETA_USER
  • Policy: Build v2.2.0-rc1
  • Priority: 1
3

Production Rollout

After successful testing, update the global policy to v2.2.0 and remove overrides.
Controlled rollout minimizes risk and ensures thorough testing.

Scenario 3: Emergency rollback

Quickly rolling back from a problematic build:
1

Identify Issue

A critical issue is discovered in the current production build v2.3.0.
2

Create Emergency Override

Create a temporary override for affected users:
  • Override Type: Role
  • Applies To: ALL_USERS
  • Policy: Build v2.2.5 (last stable)
  • Priority: 0
3

Permanent Fix

After the issue is resolved, update the global policy and remove the emergency override.
Emergency overrides should be temporary and replaced with proper global policy updates.

Conclusion

The Active Policy feature in FlowX.AI provides comprehensive control over project version management through both global policies and granular policy overrides. This dual-layer approach enables:
  • Flexible Testing: Independent testing of different builds and branches by different user groups
  • Controlled Deployment: Gradual rollouts with priority-based conflict resolution
  • Enhanced Stability: Quick rollback capabilities and isolated testing environments
  • User-Centric Management: Granular control at both user and role levels
By combining global policies with targeted overrides, Active Policy ensures that the right users access the right project versions at the right time, making it an essential tool for modern development and deployment workflows.
Start with simple global policies and gradually introduce overrides as your testing and deployment needs become more complex.