Automate Multi-Step File Transfers in a Single Workflow

Getting Started

Basic Concept

Connect transfers, processing, and conditional branches into one file-processing workflow

File processing often involves more than a single transfer. You may need to transfer files to another system, run a processing program, distribute the results to multiple locations, or run different tasks depending on the processing outcome.

For example, you can transfer source files to a processing server, run a conversion job, and then distribute the generated results to multiple servers and storage systems at the same time.

If each task runs independently, you may need to manage which task should start after the previous one completes, whether multiple tasks should run in parallel, and which path the workflow should follow based on processing results.

With INNORIX Flow, file-transfer and processing tasks that previously ran independently can be connected into one execution flow built around the overall file-processing objective.

Each stage can run sequentially based on the completion result of the previous stage, branch to multiple targets in parallel, or continue along different paths based on conditions.

                   Start
                     │
                     ▼
              File Transfer
                     │
                     ▼
                 Process
                     │
            ┌────────┴────────┐
            │                 │
            ▼                 ▼
        Server A          Server B
            │                 │
            └────────┬────────┘
                     │
                     ▼
                Result Check
                     │
               ┌─────┴─────┐
               ▼           ▼
            Complete      Review

A workflow is not limited to arranging multiple tasks in sequence. Depending on the file-processing objective, you can combine sequential execution, parallel processing, conditional branching, and result verification to define the required task relationships.

For example, after transferring a source file to a processing server and generating the converted output, you can distribute the result to multiple targets in parallel and review the outcome of each task.

Source File
     │
     ▼
Transfer to Processing Server
     │
     ▼
Run Processing
     │
     ▼
Result Files
     │
 ┌───┼───────────────┐
 ▼   ▼               ▼
Web Server      Archive Storage
     │               │
     └───────┬───────┘
             ▼
        Result Check

This lets you manage multi-stage file operations such as file preparation → transfer → processing → result generation → distribution by target → execution result verification within a single Flow instead of running and checking each transfer and processing task separately.

Execution Methods

Process tasks in sequence or branch to multiple targets in parallel

Not every task in a Flow needs to run the same way.

Connect tasks sequentially when one stage must finish before the next can start, and use parallel branches when the same file needs to be distributed to multiple systems.

For example, you can process one source file first, then distribute the generated output to multiple environments in parallel.

Raw Data
    │
    ▼
Processing Server
    │
    ▼
Result File
    │
 ┌──┼───────────┐
 ▼  ▼           ▼
NAS Cloud    Backup
 │    │           │
 └────┴─────┬─────┘
            ▼
       Result Check

This allows different execution structures to be combined within one Flow based on the file movement path and task characteristics.

Automation Scope

Continue through post-transfer processing and result verification

A workflow does not end after a file is transferred once.

You can build a single flow that runs a processing program after the file arrives, transfers the result to other systems, and verifies the completion status of the overall job.

┌──────────┐
│ Source   │
└────┬─────┘
     │
     ▼
┌──────────┐
│ Transfer │
└────┬─────┘
     │
     ▼
┌──────────┐
│ Process  │
└────┬─────┘
     │
     ▼
┌──────────┐
│ Distribute│
└────┬─────┘
     │
     ▼
┌──────────┐
│ Complete │
└──────────┘

This lets you manage multi-stage file work such as file collection → transfer → processing → branched distribution → result verification as a single automation unit.

IT Engineers

Start Conditions

Configure the event and execution criteria that start the file workflow

First, define the condition that starts the overall workflow.

The workflow can start when a new file is created or be triggered after a specific transfer job completes.

Start conditions can be configured differently depending on the workflow purpose.

Configuring start conditions lets you automate not just individual stages, but the entire file-processing workflow itself.

Chain Stages

Continue to the next task based on the completion result of the previous stage

When multiple stages must run in order, use the result of the previous task as the execution condition for the next stage.

For example, start conversion on the processing server only after the source file transfer completes, then transfer the result file to the next system after conversion finishes.

Stage 1                 Stage 2                 Stage 3

Source
   │
   ▼
Transfer ──────► Process ──────► Result Transfer
   │                  │                  │
Completed          Completed          Completed

When sequential execution is required, stage relationships can be configured using criteria like the following.

• Start processing only after the source file transfers successfully

• Run the next task after file validation completes

• Transfer the result file after processing generates the output

• Wait or stop subsequent tasks if the previous stage fails

• End the overall Flow after all required stages complete

This makes the execution order of each task explicit and manageable.

Parallel Distribution

Transfer one file to multiple systems at the same time

When the same file or processing result is required in multiple environments, branch from one stage into multiple transfer jobs.

For example, you can transfer a processed file to a production server, backup storage, and a cloud environment in parallel.

                    Result File
                         │
                         ▼
                  ┌────────────┐
                  │ Distribution│
                  └──────┬─────┘
              ┌──────────┼──────────┐
              ▼          ▼          ▼
         Production    Backup      Cloud
           Server     Storage     Storage

Parallel distribution lets multiple target operations run together instead of waiting for one target transfer to finish before starting another.

This lets you manage distribution of the same file to multiple work environments within a single stage.

Conditional Branching

Run different tasks based on file state and processing results

Not every file needs to follow the same processing path.

You can define different processing paths based on file type, validation result, or whether the previous task succeeded.

                    File Check
                        │
                ┌───────┴────────┐
                │                │
           Valid File        Invalid File
                │                │
                ▼                ▼
           Processing       Error Storage
                │                │
                ▼                ▼
          Result Transfer    Review Queue

Conditional branching can be used in situations like the following.

This allows a Flow to select the appropriate processing path automatically based on file state.

Result Processing

Collect results from multiple stages and connect them to the next task

When sequential and parallel tasks are combined, manage the overall workflow result based on the completion state of each stage.

For example, after distributing files to multiple servers, you can record the final result or start the next workflow once all required targets complete successfully.

        Processing Complete
                │
       ┌────────┼────────┐
       ▼        ▼        ▼
    Server A  Server B  Server C
       │        │        │
       ✓        ✓        ✓
       └────────┼────────┘
                ▼
          Result Collected
                │
                ▼
           Next Workflow

At the final stage, connect the next task based on the overall execution result.

• Mark the workflow complete when files are applied successfully to all targets

• Start the next Flow after confirming results from the required targets

• Record a needs-review state when some tasks encounter problems

• Transfer processing results to another system or storage location

• Send the overall execution result to notification or monitoring systems

This lets you manage processing status at the workflow level instead of checking each task result separately.

Run Tracking

Review the status of the overall Flow and each individual stage together

In a multi-stage workflow, it is important to know not only whether the overall job has completed, but also which stage is currently running.

In Runs, you can review overall progress and the result of each stage for a workflow execution.

For example, you can review the overall flow as follows.

Workflow Run

[✓] File Transfer
        │
[✓] Validation
        │
[✓] Processing
        │
 ┌──────┼──────┐
[✓]    [✓]    [!] 
Server A Server B Server C
                  │
                  ▼
             Needs Review

Review workflow status using items like the following.

This lets you track both the overall flow and individual stage status even when multiple transfer and processing jobs are connected.

Exception Flow

Review the overall job state and reprocess only the required part when a stage fails

In a multi-stage workflow, a failure in one stage does not always require restarting the entire job.

Use the execution results to identify the failed stage and affected downstream tasks, then rerun only the necessary portion.

                    Workflow Run
                         │
                         ▼
                 ┌──────────────┐
                 │ Failed Stage │
                 └──────┬───────┘
                        │
            ┌───────────┼───────────┐
            ▼           ▼           ▼
        Source       Condition      Target
         Check         Check         Check
            │           │           │
            └───────────┼───────────┘
                        ▼
                   Fix Settings
                        │
                        ▼
                    Retry Stage
                        │
                        ▼
                 Continue Workflow

When a problem occurs, identify the cause based on the characteristics of the failed stage instead of reviewing the entire Flow at once.

A multi-stage file workflow extends beyond simple file transfer by connecting sequential processing → parallel distribution → conditional branching → result collection → exception handling within one Flow.

Instead of running and managing each task separately, combine the required operations according to the flow of files and processing results to build an automation structure that matches the actual work environment.