Skip to main content

Exit Point

Great question! Exit Point in NICE Actimize refers to specific locations in the processing flow where the system can branch, terminate, or hand off control to external processes or custom logic.

What is an Exit Point?​

An Exit Point is a predefined location in the Actimize processing workflow where:

  • Custom code can be executed
  • External systems can be called
  • Processing flow can be altered or terminated
  • Additional logic can be injected without modifying core system code

Think of it as a "hook" or "extension point" where you can plug in custom functionality.

Types of Exit Points in NICE Actimize:​

1. Scenario Exit Points​

Scenario Processing Flow:
Data Input → Pre-Processing → [EXIT POINT 1] →
Scenario Logic → [EXIT POINT 2] →
Decision Making → [EXIT POINT 3] →
Output/Action → [EXIT POINT 4]

Common Scenario Exit Points:

  • Pre-scenario: Before scenario logic executes
  • Post-scenario: After scenario completes
  • Decision point: During risk scoring
  • Action point: Before/after actions are taken

2. Transaction Processing Exit Points​

Transaction Flow:
Ingestion → Validation → [EXIT POINT] →
Enrichment → [EXIT POINT] →
Scoring → [EXIT POINT] →
Decision → [EXIT POINT] → Response

3. Investigation Workflow Exit Points​

Investigation Flow:
Alert Creation → [EXIT POINT] →
Case Assignment → [EXIT POINT] →
Investigation → [EXIT POINT] →
Resolution → [EXIT POINT]

4. Batch Processing Exit Points​

Batch Job Flow:
Data Load → [EXIT POINT] →
Processing → [EXIT POINT] →
Validation → [EXIT POINT] →
Completion → [EXIT POINT]

Real-Life Examples:​

Example 1: Custom Risk Scoring Exit Point​

Business Need: Bank wants to integrate proprietary machine learning model for additional risk scoring.

Implementation:

Configuration Location:
Scenario Designer → Advanced → Exit Points → Post-Scenario Processing

Exit Point Configuration:
- Name: "CustomMLRiskScoring"
- Trigger: After fraud scenario execution
- Type: External Executable
- Path: /opt/bank/ml_models/fraud_scorer.py
- Input: Transaction data + initial risk score
- Output: Enhanced risk score

Processing Flow:

1. Transaction arrives
2. Standard Actimize scenarios execute → Risk Score: 150
3. EXIT POINT triggered
4. Custom ML model executes → Additional Score: +50
5. Final Risk Score: 200
6. Continue with decision logic

Example 2: External System Integration Exit Point​

Business Need: Integrate with external fraud consortium database for real-time checks.

Implementation:

Exit Point: Pre-Decision Processing
Action: Call external API
Configuration:
- Trigger Condition: Risk score > 100
- External Service: FraudConsortium API
- Timeout: 500ms
- Fallback: Continue without external data if timeout

Processing Flow:

1. Transaction processed → Risk Score: 120
2. EXIT POINT triggered (score > 100)
3. API call to fraud consortium
4. External response: "Known fraud pattern detected"
5. Adjust risk score: 120 → 250
6. Continue with enhanced decision making

Example 3: Custom Alert Routing Exit Point​

Business Need: Route high-value customer alerts to specialized team.

Implementation:

Exit Point: Alert Generation Post-Processing
Configuration:
- Trigger: Alert created AND customer_tier = "PREMIUM"
- Action: Custom routing logic
- Script: /opt/actimize/scripts/premium_routing.sh

Processing Flow:

1. Alert generated for premium customer
2. EXIT POINT triggered
3. Custom routing script executes:
   - Check specialist team availability
   - If available: Assign to premium team
   - If not available: Escalate to manager
4. Alert routed appropriately

Configuration and Implementation:​

1. Exit Point Configuration in AIS Admin​

AIS Admin Console → System Configuration → Exit Points

Configuration Fields:

  • Exit Point Name: Unique identifier
  • Trigger Condition: When to execute
  • Execution Type: Script, executable, API call
  • Parameters: Input/output definitions
  • Error Handling: What to do if exit point fails
  • Timeout: Maximum execution time

2. Common Configuration Patterns:​

Pre-Processing Exit Point:​

<exit-point name="PreScenarioValidation">
    <trigger>before-scenario-execution</trigger>
    <condition>transaction_amount > 10000</condition>
    <action type="executable">/opt/validation/high_value_check.sh</action>
    <timeout>2000</timeout>
    <on-failure>continue</on-failure>
</exit-point>

Post-Processing Exit Point:​

<exit-point name="CustomNotification">
    <trigger>after-alert-generation</trigger>
    <condition>alert_priority = "CRITICAL"</condition>
    <action type="api-call">
        <url>https://notification.bank.com/api/send</url>
        <method>POST</method>
        <payload>${alert_data}</payload>
    </action>
    <timeout>5000</timeout>
    <on-failure>log-and-continue</on-failure>
</exit-point>

Exit Point Use Cases:​

1. Data Enrichment​

  • Purpose: Add external data to transactions
  • Examples: Credit scores, device fingerprinting, geolocation
  • Trigger: During transaction processing
  • Implementation: API calls to external services

2. Custom Scoring Models​

  • Purpose: Supplement standard risk scoring
  • Examples: Machine learning models, behavioral analytics
  • Trigger: After initial risk calculation
  • Implementation: Python/R scripts, ML model servers

3. External System Integration​

  • Purpose: Integrate with non-Actimize systems
  • Examples: Core banking, CRM, regulatory reporting
  • Trigger: Various points in processing
  • Implementation: APIs, file transfers, database calls

4. Custom Business Logic​

  • Purpose: Implement bank-specific rules
  • Examples: VIP customer handling, regulatory requirements
  • Trigger: Based on business conditions
  • Implementation: Custom scripts and executables

5. Audit and Compliance​

  • Purpose: Additional logging and monitoring
  • Examples: Regulatory audit trails, performance monitoring
  • Trigger: At completion of major processing steps
  • Implementation: Log files, database inserts, external monitoring

Best Practices for Exit Points:​

1. Performance Considerations​

  • Keep execution time minimal (< 500ms for real-time)
  • Implement timeouts to prevent blocking
  • Use asynchronous processing when possible
  • Cache frequently accessed data

2. Error Handling​

  • Define clear failure modes: Continue, retry, abort
  • Implement fallback logic for external dependencies
  • Log all errors for troubleshooting
  • Test failure scenarios thoroughly

3. Security​

  • Validate all inputs to exit point scripts
  • Use secure communication (HTTPS, encryption)
  • Implement proper authentication for external calls
  • Audit exit point executions

4. Maintenance​

  • Version control exit point scripts
  • Document all exit points and their purposes
  • Monitor performance and success rates
  • Regular testing of exit point functionality

Monitoring Exit Points:​

Performance Metrics:​

  • Execution time: Average and maximum
  • Success rate: Percentage of successful executions
  • Error frequency: Types and patterns of failures
  • Impact on throughput: Effect on overall processing speed

Monitoring Tools:​

AIS Admin Console → Monitoring → Exit Point Performance
- Real-time execution status
- Historical performance data
- Error logs and analysis
- Resource utilization metrics

Exit points provide powerful extensibility to NICE Actimize, allowing organizations to customize the platform without modifying core system code, while maintaining upgrade compatibility and system stability.