Purpose

This guide explains how to build and run a complete BPMN workflow in SynapArk through the user interface. It covers Applications, Workflow Forms, DMN Decisions, BPMN modeling, task assignment and claiming, process execution, and completion.

Three complete examples are included:

1. Library book borrowing
2. New stock addition in inventory
3. Loan application

Before you begin

Sign in with an account that has permission to create applications, design and publish forms, deploy decisions and processes, start processes, and work on tasks. If an action is missing, ask an administrator to review your role under Users & access.

Keep these rules in mind:

• A key is a stable technical identifier. Use lowercase letters, numbers, and hyphens, such as library-borrowing.
• In the primary Application flow, create Forms and Decisions from the Application Design workspace. Their draft versions are frozen and activated together with the Application release.
• The top-level Forms, Decisions, Processes, and Cases pages remain available for independent resources and existing integrations, but new solutions should be designed inside an Application.
• A process must contain a Start Event, connected executable activities, and an End Event.
• Every gateway route should either have a condition or be the gateway's default route.
• Form field keys and DMN input expressions must match. For example, the form field credit_score feeds a DMN input expression named credit_score.
• A new Application process starts from Work only after its immutable version has been successfully deployed. Processes remains the Standalone compatibility runtime.

The complete UI flow

Create Application -> open Design
       |
       +--> Create Application Form draft (when input is required)
       +--> Create Application DMN draft (when rules are required)
       +--> Create Application BPMN draft; bind Form/DMN; mark Entry point
       |
       +--> Validate dependencies -> create immutable version
       +--> Deploy version to an environment (then promote/approve as required)
       |
       +--> Open Work -> Application -> start exact activated entry point
       |
       +--> Claim/perform tasks
       |
       +--> Reach End Event and verify completion

Part 1: Create an Application

1. In the left navigation, select Applications.
2. Select New application.
3. Complete the form:
   • Name: a clear internal name.
   • Application key: select the small key-generation icon to derive a slug from the name, or type a key manually.
   • Display name: the user-facing name.
   • Initial semantic version: normally 1.0.0.
   • Description: explain the business purpose.
4. Select Create application.

The Application opens on its Overview page. Select Design; this is the primary workspace for every new Form, DMN, BPMN, and CMMN resource owned by this solution.

Link an existing resource when needed

Normally, create new BPMN, CMMN, DMN, and Form resources directly under Design. To adopt an eligible existing resource instead:

1. Open the Application and select Resources.
2. Under Link an existing resource, choose the resource type.
3. Open Available resource and search by display name or definition key. Search runs across all eligible resources, not only the first ten results.
4. Use Load more inside the selector when you want to browse additional matches.
5. For a BPMN process or CMMN case, enable Entry point only when workers should be able to launch it from Work.
6. Select Review and link.
7. In Review resource dependencies, inspect the complete bundle. SynapArk recursively discovers referenced Forms, DMNs, and called BPMN processes. Resources marked will link are adopted with the process; resources marked linked are already available in the Application.
8. If the review reports a missing or conflicting dependency, close the dialog and resolve it first. Otherwise, select Link resources. The complete bundle is linked atomically.

The selector excludes resources and logical keys already linked to this Application. A resource owned by another Application cannot be adopted. Supporting dependencies are never silently moved: the modal shows the exact revision and ownership change before anything is written.

To unlink a resource, select its trash icon in the Resources table. Unlinking removes the resource from the Application draft. Normally the revision returns to the Standalone registry. If a Standalone revision already has the same definition key/version (or already occupies the latest slot), SynapArk safely retains the detached revision’s Application ownership instead of overwriting either revision. The UI confirms this outcome, and the revision remains searchable so it can be linked back to the same Application later.

Part 2: Create and publish a Workflow Form

Create a form only when a user task must collect structured information.

1. Open the Application and select Design.
2. Select New Workflow form.
3. Enter the Form name, Definition key, category, and description.
4. Add fields from Field library:
   • Drag a field onto Form canvas, or select the field type to add it.
   • Drag existing fields to reorder them.
5. Select each field and configure Field settings:
   • Label is shown to the task worker.
   • Field key becomes the process variable name.
   • Use the small key-generation icon to derive the key from the label when helpful.
   • Configure required state, width, validation, options, and conditional visibility.
   • Enable Read only when the field should display an existing process-variable value without allowing the task worker to edit it. The value remains part of the submitted form data.
6. Use Preview to test the layout and validation.
7. Select Save draft. Return to Application design.
8. Confirm the Form appears under the Application’s Forms filter. It becomes immutable and executable only when the Application version is created and deployed.

Do not recreate this resource in the top-level Form catalog. Application modeler selectors resolve resources owned by the same Application, preventing cross-release drift.

Part 3: Create and deploy a DMN Decision

Create a decision table when routing should be based on repeatable business rules rather than a manual choice.

1. From the Application Design workspace, select New DMN decision.
2. Select New decision table.
3. Enter the Definition key, Display name, and description.
4. Select a Hit policy. Use FIRST for the examples in this guide so the first matching rule produces the result.
5. Configure input columns:
   • Input label: readable column title.
   • Input FEEL expression: the exact process variable or form field key, such as member_active or credit_score.
   • Input type: string, number, or boolean as appropriate.
6. Configure an output column:
   • Output variable name: for example eligibility.
   • Output type: normally string for routing outcomes.
   • Optionally list ordered allowed values using quoted strings.
7. Enter FEEL unary tests in input cells. Common values are:
   • - for any value.
   • true or false for booleans.
   • >= 700 for a numeric comparison.
   • [600..699] for an inclusive range.
   • "available" for a string value.
8. Enter string outputs in quotes, such as "approved".
9. Select Add rule for additional outcomes.
10. Select Save draft and return to Application Design.
11. Reopen the draft when needed to test representative inputs before linking it to a process.
12. The Decision is activated with the exact Application release; there is no separate standalone deployment step.

Part 4: Create the BPMN process

1. From the Application Design workspace, select New BPMN process.
2. The modeler opens a fresh Application-owned process workspace.
3. Enter the process Definition key, Display name, and description above the canvas.
4. Select the Process or Participant on the canvas and confirm Executable process in Element properties.
5. Build the process using the BPMN palette:
   • Add a Start Event.
   • Add User Tasks for human work.
   • Add a Business Rule Task for DMN evaluation when needed.
   • Add an Exclusive Gateway for conditional routing.
   • Add one or more End Events.
   • Use the element context actions to connect each element with Sequence Flows.
6. Select each element on the canvas. The right-side Element properties panel changes for the selected element.
7. Give every task, event, and gateway a meaningful Name.

Link a Form to a User Task

1. Select the User Task or Manual Task.
2. Under Task form, choose the form from Published form.
3. Under Task assignment, choose one of these patterns:
   • Direct assignee: the task appears immediately for one user.
   • Candidate users: selected users can see and claim the task.
   • Candidate groups: members of selected groups can see and claim the task.
   • No assignment: any permitted task worker can claim it.

Link a DMN Decision

1. Select the Business Rule Task.
2. Under Called decision, choose the table from Active decision.
3. For a single routing output, leave Result variable empty so the decision output is merged into process variables. For example, a DMN output named eligibility becomes the process variable eligibility.
4. If you enter a Result variable, the complete decision output is stored below that name and gateway expressions must reference the nested result accordingly.

Configure gateway routes

1. Select the Sequence Flow leaving the Exclusive Gateway.
2. Under Routing, choose the process-variable path, comparison operator, value type, and comparison value. SynapArk generates the condition expression.
3. Use eligibility when the DMN output was merged. When a Business Rule Task stores the full output under Result variable result, use a nested path such as result.eligibility or result.result.
4. Configure one unconditional/default route for unmatched results. Use the gateway's replace/configure controls to mark the intended Sequence Flow as default when required.

Save and mark the entry point

1. Review the entire diagram and confirm that every element is connected.
2. Confirm that linked Form and DMN keys are correct.
3. Select Save draft.
4. Wait for the named saving state to finish and return to Application Design.
5. Enable Entry point for this BPMN resource. A process that is not an entry point is packaged as an internal dependency and cannot be launched from Work.

Editing and redeploying an existing definition creates a new version; it does not rewrite the old version.

Part 5: Validate, version, and deploy the Application

1. Return to the Application Overview. The resources created through Design are already owned by it; do not link duplicate standalone definitions.
2. Open Versions.
3. Select Validate current draft.
4. Review the resource/element diagnostics and resolve every missing Form, Decision, called-process, ownership, or entry-point error in Design.
5. Validate again after every change.
6. Resolve every missing form, decision, or called-process warning.
7. Enter a semantic version such as 1.0.0, add release notes, and select Create validated version.

The resulting application version is immutable and pins the exact resource versions and checksums.

Deploy the immutable version

Application deployment is mandatory for the Application-first runtime.

1. Open Environments in the application and create the required stages.
2. Open Deployments.
3. Choose the immutable application version and Development environment.
4. Select Preflight and resolve any reported problem.
5. Select Deploy and confirm.
6. In the deployment history, use Promote on the row marked current to move the unchanged version to the next configured stage. The button disappears when that version is already active or awaiting deployment in the next stage.
7. Production requires an eligible user other than the deployment initiator to approve the pending deployment.

Rollback is shown only on the current deployment when that environment has an older successful, different Application version. Rollback creates a new deployment of that historical version for new starts; it does not delete history or move already-running instances.

Part 6: Start and complete the published process

Start the instance

1. Select Work.
2. Open the published Application and confirm the expected environment/version badge.
3. Find the BPMN entry point and select Start.
4. If a Start Form is bound, complete it and select Submit and start. Otherwise optionally enter:
   • Business key: an external reference such as APP-2026-000123.
   • Instance name: a readable case name.
   • Initial variables: a valid JSON object. Use {} when the first task collects all required data.
5. Select Start workflow and retain the returned instance ID.

Start Form values and Initial variables become process variables. For example, entering username in a Start Form or starting with { "username": "Ayesha" } makes that value available to downstream nodes.

Claim and perform a task

1. Select Tasks.
2. Use the appropriate view:
   • My work for your assigned and claimed work.
   • Assigned to me for direct assignments.
   • Available to claim for candidate work.
   • All open for administrators testing the workflow.
3. Find the task.
4. Select Claim if it is unassigned.
5. Select Complete.
6. If a form is linked, it opens in a completion dialog. Fields whose keys exactly match existing process-variable keys are prefilled automatically. For example, a later Form field keyed username shows the current username value from the Start Form, initial JSON, DMN output, or an earlier task. Complete all required fields and select Submit and complete. Submitted values update those process variables for downstream nodes. You may close the dialog before submission, but it remains locked while the completion request is running.
7. Repeat for each new task created by the process.

The process advances automatically through Business Rule Tasks and gateways. A task that is not offered to you will not appear in your personal task view.

Verify successful completion

1. Open Operations (or follow the Application context from the task).
2. Find the instance using its business key.
3. Confirm the status is completed.
4. In Operations, open the instance to inspect its diagram token path, timeline, tasks, variables, decision effects, events, jobs, and audit history.

If the instance remains running, inspect the current wait state. It normally indicates an uncompleted task, timer, message/event wait, or external job.

Example 1: Library book borrowing

Business goal

A member requests a book. A librarian records the request, a decision checks eligibility and availability, and the request is either issued, placed on hold, or rejected.

Resource names and keys

Create the form

Create and publish Book borrowing request with these fields:

Create the decision

Create Borrowing eligibility with hit policy FIRST.

Inputs:

Output: borrowing_status as string.

Rules:

Deploy the decision and test it with:

{
  "member_active": true,
  "outstanding_fines": 0,
  "book_available": true
}

Build the BPMN model

Borrow request received
  -> Record borrowing request [User Task + Form]
  -> Check borrowing eligibility [Business Rule Task + DMN]
  -> Borrowing outcome [Exclusive Gateway]
       approved -> Issue book [User Task]
       hold     -> Place reservation [User Task, default route]
       rejected -> Notify rejection [User Task]
  -> Request closed [End Event]

Set gateway conditions:

• Issue book: ${borrowing_status == "approved"}
• Notify rejection: ${borrowing_status == "rejected"}
• Place reservation: default route

Link the published form to Record borrowing request. Assign Issue book and Place reservation to librarian candidates. Link the active DMN to Check borrowing eligibility and leave Result variable empty.

Run the successful path

1. Start with business key BORROW-2026-0001 and variables {}.
2. In Available to claim, claim Record borrowing request.
3. Complete the form using an active member, zero fines, and an available book.
4. Claim and complete Issue book.
5. In Operations, confirm BORROW-2026-0001 is completed and borrowing_status is approved.

Example 2: New stock addition in inventory

Business goal

A warehouse worker records incoming stock. A decision classifies the inspection outcome, then inventory is either updated, sent for review, or rejected.

Resource names and keys

Create the form

Publish the form.

Create the decision

Create Stock acceptance, hit policy FIRST.

Inputs: quantity_received (number), po_matched (boolean), and damaged_units (number).

Output: stock_status (string).

Build the BPMN model

Shipment arrived
  -> Inspect and record stock [User Task + Form]
  -> Evaluate stock acceptance [Business Rule Task + DMN]
  -> Inspection outcome [Exclusive Gateway]
       accepted -> Add quantity to inventory [User Task]
       review   -> Supervisor damage review [User Task, default route]
       rejected -> Record supplier rejection [User Task]
  -> Receipt completed [End Event]

Conditions:

• Add quantity: ${stock_status == "accepted"}
• Supplier rejection: ${stock_status == "rejected"}
• Supervisor review: default route

Assign inspection and inventory tasks to a Warehouse candidate group and review to an Inventory Supervisor group.

Run the successful path

1. Start with business key RECEIPT-2026-0042 and {}.
2. Claim Inspect and record stock.
3. Submit SKU-1007, quantity 50, PO matched, damaged units 0, and inspection notes.
4. Claim and complete Add quantity to inventory.
5. Verify completion in Operations and confirm stock_status is accepted.

Example 3: Loan application

Business goal

An officer captures applicant data. A DMN table determines whether the loan is approved, requires manual review, or is declined. The selected human task finishes the case.

Resource names and keys

Create the form

Publish the form.

Create the decision

Create Loan eligibility, hit policy FIRST.

Inputs: age and credit_score, both number.

Output: eligibility, string, with allowed values "approved", "review", "declined".

Deploy and test with { "age": 34, "credit_score": 745 }.

Build the BPMN model

Application received
  -> Capture loan application [User Task + Form]
  -> Evaluate loan eligibility [Business Rule Task + DMN]
  -> Eligibility outcome [Exclusive Gateway]
       approved -> Approve eligible application [User Task]
       review   -> Manually review application [User Task, default route]
       declined -> Record declined application [User Task]
  -> Application completed [End Event]

Conditions:

• Approval: ${eligibility == "approved"}
• Decline: ${eligibility == "declined"}
• Manual review: default route

Link Loan application review to the capture task and Loan eligibility to the Business Rule Task. Leave Result variable empty. Assign the capture task to loan-officer candidates and the approval/review tasks to authorized credit officers.

Run the approved path

1. Start with business key LOAN-2026-000123, instance name Jordan Smith loan request, and {}.
2. Claim Capture loan application.
3. Submit age 34, credit score 745, the requested amount, applicant name, and notes.
4. The decision sets eligibility to approved and routes to Approve eligible application.
5. Claim and complete the approval task.
6. Open Operations, search for LOAN-2026-000123, and confirm:
   • Status is completed.
   • The timeline reaches Application completed.
   • The tasks are completed.
   • eligibility is approved.

Troubleshooting

Completion checklist

• Application created with a stable key.
• Required Form created and previewed inside Application Design.
• Required DMN table created and tested inside Application Design.
• BPMN process marked executable.
• Start Event, tasks, gateways, and End Event fully connected.
• User Tasks have correct forms and assignments.
• Business Rule Tasks reference Decisions from the same Application.
• Gateway conditions and default routes are configured.
• BPMN entry-point toggle enabled.
• BPMN, DMN, and Form are owned by the same Application draft.
• Application dependencies validated, immutable version created, and deployment succeeded.
• Process started with a traceable business key.
• Every human task claimed/assigned and completed.
• Final instance status verified as completed in Operations.