Skip to main content

​
Workflow Automation Guide

Build resilient, scalable workflows using OpsHub’s Temporal-based orchestration engine. From simple automation to complex multi-step processes with error handling and retries.

​
Temporal Architecture

OpsHub leverages Temporal for durable workflow execution:
  • Fault Tolerance: Workflows survive failures and resume automatically
  • Event Sourcing: Complete history of all workflow executions
  • Scalability: Handle thousands of concurrent workflows
  • Long-Running: Support for workflows running days or months
  • Versioning: Safe deployment of workflow changes

​
Creating Workflows

​
Visual Workflow Builder

Design workflows using the drag-and-drop interface:
  1. Navigate to Workflows → Create New
  2. Select workflow template or start from scratch
  3. Drag activities from the palette
  4. Connect activities to define flow
  5. Configure each activity’s parameters
  6. Set error handling and retry policies
  7. Test and deploy

​
Code-Based Workflows

Define workflows programmatically: 
import { proxyActivities, defineWorkflow } from '@temporalio/workflow';

const activities = proxyActivities({
  startRetryTime: '1 second',
  maximumAttempts: 3
});

export async function navCalculationWorkflow(fundId: string) {
  // Step 1: Fetch positions
  const positions = await activities.fetchPositions(fundId);
  
  // Step 2: Get market prices (parallel)
  const prices = await Promise.all(
    positions.map(p => activities.getMarketPrice(p.securityId))
  );
  
  // Step 3: Calculate NAV
  const nav = await activities.calculateNAV(positions, prices);
  
  // Step 4: Validate and store
  await activities.validateNAV(nav);
  await activities.storeNAV(nav);
  
  return nav;
}

​
Common Workflow Patterns

​
Daily NAV Calculation

Automated daily NAV calculation with validation: 
export async function dailyNAVWorkflow() {
  const funds = await activities.getActiveFunds();
  
  for (const fund of funds) {
    await childWorkflow.execute(navCalculationWorkflow, {
      args: [fund.id],
      workflowId: `nav-${fund.id}-${new Date().toISOString()}`
    });
  }
  
  // Generate reports
  await activities.generateNAVReport(funds);
  await activities.sendNotifications();
}

​
Trade Processing

End-to-end trade processing workflow: 
export async function tradeProcessingWorkflow(trade: Trade) {
  // Validation
  await activities.validateTrade(trade);
  
  // Compliance check
  const complianceResult = await activities.checkCompliance(trade);
  if (!complianceResult.approved) {
    await activities.flagForReview(trade);
    return;
  }
  
  // Execute trade
  const execution = await activities.executeTrade(trade);
  
  // Settlement
  await activities.processSettlement(execution);
  
  // Update positions
  await activities.updatePositions(execution);
  
  // Notifications
  await activities.notifyStakeholders(execution);
}

​
Error Handling

Implement robust error handling: 
export async function robustWorkflow(data: any) {
  try {
    return await activities.processData(data);
  } catch (error) {
    if (error.type === 'TEMPORARY') {
      // Retry with exponential backoff
      await sleep('30 seconds');
      return await activities.processData(data);
    } else if (error.type === 'VALIDATION') {
      // Send to manual review
      await activities.createManualTask(data);
      throw error;
    } else {
      // Log and alert
      await activities.logError(error);
      await activities.sendAlert(error);
      throw error;
    }
  }
}

​
Scheduling & Triggers

​
Cron Schedules

Set up recurring workflows: 
// Schedule daily at 6 PM
await client.schedule.create({
  action: {
    type: 'startWorkflow',
    workflowType: dailyNAVWorkflow
  },
  scheduleId: 'daily-nav-calc',
  spec: {
    cronExpressions: ['0 18 * * *'],
    timezoneName: 'America/New_York'
  }
});

​
Event Triggers

React to events: 
// Trigger on file upload
supabase.storage
  .from('uploads')
  .on('INSERT', async (file) => {
    await client.workflow.start(processFileWorkflow, {
      args: [file.path],
      workflowId: `process-${file.id}`
    });
  });

​
Monitoring & Observability

Track workflow execution:
  • Real-time Dashboard: Monitor running workflows
  • Execution History: View completed workflows
  • Performance Metrics: Response times and throughput
  • Error Tracking: Failed workflows and retry attempts
  • Audit Trail: Complete execution history

​
Best Practices

  • Idempotency: Ensure activities can be safely retried
  • Timeouts: Set appropriate timeouts for activities
  • Versioning: Use workflow versioning for updates
  • Testing: Write unit tests for workflows
  • Documentation: Document workflow logic and dependencies
Next Steps: Explore Dashboard Guide for visualizing workflow data.