Skip Failed Task

Overview

The SkipFailedTaskCommand bypasses a failed task and continues process execution from the next task. This is used when a task fails but the process can continue without it.

Use with Caution

Skipping a failed task means that task's logic was not executed. Ensure downstream tasks can handle missing data or outputs from the skipped task.

API Endpoint

POST /api/core/cmd

Headers

Content-Type: application/json
Authorization: Bearer {access_token}
X-Tenant-ID: {tenant_id}

Request Structure

{
  "cmd": "SkipFailedTaskCommand",
  "data": {
    "instanceGuid": "abc-123-def-456",
    "comment": "External service unavailable, proceeding without credit check",
    "additionalData": {
      "creditScore": 0,
      "creditCheckSkipped": true
    }
  }
}

Request Fields

Field	Type	Required	Description
instanceGuid	string	Yes	The unique identifier of the process instance with failed task
comment	string	No	Reason for skipping the task (for audit trail)
additionalData	object	No	Variables to set for downstream tasks

When to Use

✅ Good Use Cases

• Non-Critical Service Unavailable: External service down but not essential
• Optional Enrichment: Data enrichment failed but process can continue
• Degraded Mode: Continue with limited functionality
• Manual Workaround: Task will be handled manually later

❌ Bad Use Cases

• Critical Validation: Never skip essential validation tasks
• Required Data: Task provides data needed by downstream tasks
• Security Checks: Never skip authentication/authorization tasks
• Financial Calculations: Never skip calculations affecting money

Sample Requests

1. Skip Failed External Service Call

{
  "cmd": "SkipFailedTaskCommand",
  "data": {
    "instanceGuid": "loan-app-2024-001",
    "comment": "Credit bureau API timeout - proceeding with manual review flag",
    "additionalData": {
      "creditCheckSkipped": true,
      "manualReviewRequired": true,
      "skipReason": "External service unavailable"
    }
  }
}

2. Skip Optional Notification

{
  "cmd": "SkipFailedTaskCommand",
  "data": {
    "instanceGuid": "account-opening-456",
    "comment": "Email service down - notification will be sent later via batch job"
  }
}

3. Skip Non-Critical Enrichment

{
  "cmd": "SkipFailedTaskCommand",
  "data": {
    "instanceGuid": "kyc-process-789",
    "comment": "Address verification service unavailable - will verify manually",
    "additionalData": {
      "addressVerified": false,
      "verificationMethod": "manual_pending"
    }
  }
}

Response Structure

Successfully Skipped and Continued

{
  "isSuccessful": true,
  "message": "Failed task skipped successfully.",
  "statusCode": "00",
  "data": {
    "instanceGuid": "loan-app-2024-001",
    "status": "running",
    "currentActivityId": "Task_AssessRisk",
    "skippedTask": {
      "taskId": "Task_CreditCheck",
      "taskName": "Perform Credit Check",
      "skippedAt": "2024-12-19T10:30:00Z",
      "skipReason": "Credit bureau API timeout - proceeding with manual review flag"
    },
    "result": {
      "message": "Task skipped, process continuing",
      "waiting": false
    },
    "state": {
      "variables": {
        "loanId": 789,
        "customerId": 456,
        "creditCheckSkipped": true,
        "manualReviewRequired": true,
        "skipReason": "External service unavailable"
      },
      "currentNode": "Task_AssessRisk",
      "completedTasks": [
        "StartEvent",
        "Task_ValidateCustomer"
      ],
      "skippedTasks": [
        "Task_CreditCheck"
      ]
    }
  }
}

Skipped and Waiting at Next UserTask

{
  "isSuccessful": true,
  "message": "Failed task skipped. Process waiting at next UserTask.",
  "statusCode": "00",
  "data": {
    "instanceGuid": "loan-app-2024-001",
    "status": "waiting",
    "currentActivityId": "Task_ManualReview",
    "skippedTask": {
      "taskId": "Task_CreditCheck",
      "taskName": "Perform Credit Check"
    },
    "currentTask": {
      "taskId": "Task_ManualReview",
      "taskName": "Manual Review Required",
      "taskType": "UserTask",
      "note": "Credit check was skipped - manual verification needed"
    },
    "state": {
      "variables": {
        "creditCheckSkipped": true,
        "manualReviewRequired": true
      }
    },
    "nextActions": [
      {
        "action": "approve",
        "label": "Approve After Manual Check"
      },
      {
        "action": "reject",
        "label": "Reject Application"
      }
    ]
  }
}

Error Responses

Process Not in Error State

{
  "isSuccessful": false,
  "message": "Process instance is not in error state. Current state: running",
  "statusCode": "99",
  "data": {
    "currentStatus": "running"
  }
}

Process Not Found

{
  "isSuccessful": false,
  "message": "Process instance 'invalid-guid' not found.",
  "statusCode": "99",
  "data": null
}

Skip vs Retry Decision Flow

Use Cases

1. Handle Optional External Service Failure

async function handleExternalServiceFailure(instanceGuid, failedTask) {
  if (failedTask.taskName === "EnrichCustomerData") {
    // This is optional enrichment, safe to skip
    const response = await skipFailedTask({
      instanceGuid,
      comment: `${failedTask.errorMessage} - enrichment service unavailable`,
      additionalData: {
        enrichmentSkipped: true,
        enrichmentServiceDown: true,
        enrichmentRetryScheduled: true
      }
    });
    
    // Schedule background job to enrich later
    await scheduleEnrichmentRetry(instanceGuid);
    
    return response;
  }
  
  // For other tasks, don't skip automatically
  throw new Error(`Cannot skip critical task: ${failedTask.taskName}`);
}

2. Graceful Degradation

async function handleWithGracefulDegradation(instanceGuid) {
  const state = await getProcessState(instanceGuid);
  
  if (state.data.status === "error") {
    const error = state.data.error;
    
    // Define which tasks can be skipped
    const skippableTask = {
      "Task_SendNotification": true,
      "Task_LogAnalytics": true,
      "Task_UpdateCache": true,
      "Task_EnrichData": true
    };
    
    if (skippable Tasks[error.taskId]) {
      console.warn(`Skipping non-critical task: ${error.taskName}`);
      
      return await skipFailedTask({
        instanceGuid,
        comment: `Non-critical task skipped due to: ${error.errorMessage}`,
        additionalData: {
          [`${error.taskId}_skipped`]: true,
          degradedMode: true
        }
      });
    }
    
    // Critical task - cannot skip
    throw new Error(`Critical task failed: ${error.taskName}`);
  }
}

3. Skip with Compensating Logic

async function skipWithCompensation(instanceGuid, failedTask) {
  // Provide default/fallback values for skipped task
  const compensatingData = getCompensatingData(failedTask.taskId);
  
  const response = await skipFailedTask({
    instanceGuid,
    comment: `Skipping ${failedTask.taskName} with fallback values`,
    additionalData: {
      ...compensatingData,
      taskSkipped: failedTask.taskId,
      skipTimestamp: new Date().toISOString(),
      requiresFollowUp: true
    }
  });
  
  // Log for manual follow-up
  await logSkippedTaskForFollowUp({
    instanceGuid,
    taskId: failedTask.taskId,
    reason: failedTask.errorMessage,
    compensatingData
  });
  
  return response;
}

function getCompensatingData(taskId) {
  const defaults = {
    "Task_CreditCheck": {
      creditScore: 0,
      creditCheckMethod: "manual_review_required"
    },
    "Task_AddressVerification": {
      addressVerified: false,
      verificationMethod: "pending"
    },
    "Task_FraudCheck": {
      fraudScore: 100, // Highest risk - requires manual review
      fraudCheckMethod: "manual"
    }
  };
  
  return defaults[taskId] || {};
}

4. Conditional Skip Based on Business Rules

async function conditionalSkip(instanceGuid, variables, failedTask) {
  // Business rules determine if skip is allowed
  const canSkip = evaluateSkipRules(failedTask, variables);
  
  if (!canSkip.allowed) {
    throw new Error(`Cannot skip ${failedTask.taskName}: ${canSkip.reason}`);
  }
  
  return await skipFailedTask({
    instanceGuid,
    comment: canSkip.comment,
    additionalData: canSkip.compensatingData
  });
}

function evaluateSkipRules(failedTask, variables) {
  // Example: Credit check can be skipped only for low-amount loans
  if (failedTask.taskId === "Task_CreditCheck") {
    if (variables.loanAmount <= 5000) {
      return {
        allowed: true,
        comment: "Low-amount loan - manual review sufficient",
        compensatingData: {
          creditCheckWaived: true,
          manualReviewRequired: true,
          waiverReason: "loan_amount_below_threshold"
        }
      };
    }
    return {
      allowed: false,
      reason: "Credit check required for loans above $5,000"
    };
  }
  
  return { allowed: false, reason: "Task cannot be skipped" };
}

Best Practices

1. Always Provide a Comment

Good:

{
  "comment": "Credit bureau API returned 503 Service Unavailable after 3 retry attempts. Proceeding with manual credit review as per policy DR-2024-15."
}

Bad:

{
  "comment": "Service down"
}

2. Add Compensating Data

// When skipping, provide data that downstream tasks expect
await skipFailedTask({
  instanceGuid,
  comment: "Credit check service unavailable",
  additionalData: {
    // Mark what was skipped
    creditCheckSkipped: true,
    creditCheckError: error.message,
    
    // Provide fallback values
    creditScore: null,
    creditCheckMethod: "pending_manual",
    
    // Flag for follow-up
    requiresManualReview: true,
    manualReviewReason: "automated_credit_check_failed",
    
    // Audit trail
    skippedBy: currentUser,
    skippedAt: new Date().toISOString()
  }
});

3. Define Skip Policies

const SKIP_POLICIES = {
  "Task_CreditCheck": {
    canSkip: (variables) => variables.loanAmount < 5000,
    requiresApproval: true,
    compensatingData: {
      creditCheckWaived: true,
      manualReviewRequired: true
    }
  },
  "Task_SendNotification": {
    canSkip: () => true, // Always safe to skip notifications
    requiresApproval: false,
    compensatingData: {
      notificationDeferred: true
    }
  },
  "Task_FraudCheck": {
    canSkip: () => false, // Never skip fraud checks
    requiresApproval: false
  }
};

4. Log All Skips for Audit

async function skipWithAudit(instanceGuid, comment, additionalData) {
  const response = await skipFailedTask({
    instanceGuid,
    comment,
    additionalData
  });
  
  // Log to audit system
  await auditLog.record({
    action: "SKIP_FAILED_TASK",
    instanceGuid,
    taskId: response.data.skippedTask.taskId,
    reason: comment,
    compensatingData: additionalData,
    performedBy: getCurrentUser(),
    timestamp: new Date().toISOString()
  });
  
  // Alert if critical task was skipped
  if (isCriticalTask(response.data.skippedTask.taskId)) {
    await alertManagement({
      severity: "HIGH",
      message: `Critical task skipped: ${response.data.skippedTask.taskName}`,
      instanceGuid
    });
  }
  
  return response;
}

Related Commands

• Retry Failed Task - Retry the task instead of skipping
• Get Process State - Check if process is in error state
• Cancel Process - Cancel process if skip is not appropriate

Notes

• Only works when process is in "error" state
• Process must have a failed task to skip
• The comment is stored in audit logs
• Additional data is merged into process variables
• Process continues from the next task after the skipped one
• Skipped tasks are tracked in the state
• Cannot undo a skip - process continues forward
• Some tasks should NEVER be skipped (validation, security, financial calculations)
• Always provide compensating data for downstream tasks
• Consider using retry first if failure is temporary
• Document skip policies in your organization