Core Concepts

Everything you need to manage work

From organisational structure to granular task permissions — all defined in YAML, all loaded at startup.

Organisational Hierarchy

Virtual Teams group real directory groups into an org tree. A user in frontend-team resolves upward to team engineering, then expands down to see tasks assigned to frontend-team and backend-team.

org-structure.yaml

org:
  hierarchy:
    company:
      groups: [engineering, hr, finance, management]
      permissions: [entity_admin]
    engineering:
      groups: [frontend-team, backend-team]
      permissions: [task_view, task_create]
    finance:
      groups: [finance-team, finance-managers]
      permissions: [task_view, task_create, case_view, case_create]
    management:
      groups: [directors]
      permissions: [task_view, task_create, case_view, case_create]

Task Management

BPM-driven tasks with a 4-tier permission model. Permissions resolve in strict priority — the first matching tier wins.

Tier 1 Assignee — all permissions granted

Tier 2a User Participant — role-based permissions

Tier 2b Group Participant — expanded via org hierarchy

Tier 3 Default — can claim only

13 permission flags per task • 3 case-specific permissions • Group participants inherit the highest-privilege matching role.

Case Management

Long-running cases group tasks, processes, and entities. Each case type defines numbering, allowed processes, associated form, and participant team/role assignments.

fraud-investigation.case.yaml

id: fraud-investigation
displayName: Fraud Investigation
icon: bx-search-alt
numberPrefix: FRD
numberMode: auto
formId: fraud-investigation
allowedProcesses:
  - contract-approval
participants:
  - team: legal
    role: collaborator

Custom Entities

Schema-driven data objects with five pluggable data sources. All expose the same interface — controllers and services never know which backend is in use.

JDBC REST LDAP SQL YAML

Only JDBC supports create/update/delete. All others are read-only with configurable caching. Environment variables resolve at fetch time for credentials.

Process Forms

YAML-defined forms with 12 field types, column layouts, and outcomes. Rendered dynamically at runtime.

contract-approval.form.yaml

id: contract-approval
displayName: Contract Approval
fields:
  - name: contractTitle
    label: Contract Title
    type: TEXT
    required: true
    col: col-8
  - name: amount
    label: Amount
    type: NUMBER
    required: true
    col: col-4
  - name: supplier
    label: Supplier
    type: REFERENCE
    referencedEntityTypeId: supplier

Participant Roles

Five standard roles with ascending privilege. All defined in the participant-roles block of org-structure.yaml. Auto-discovered at startup.

Viewer view only

Collaborator + comment, attach

Reviewer + complete, delete attachments

Approver + edit, delegate, manage cases

Coordinator + claim (full access)

Federated Search

Multi-source search across Alfresco CMIS and REST APIs. Configurable engines, filters, metadata display, tags, view modes, and per-result actions — all in a single YAML file.

search-configs/unified.search.yaml

id: unified
engines:
  alfresco:
    main:
      url: http://localhost:8080/alfresco
      queryTemplate: "SELECT * FROM {nodeType|cmis:document} WHERE {where}"
  rest:
    products:
      url: "https://api.example.com/search?q={query}"
ui:
  globalFilters:
    - id: query
      type: EMPTY

Studio Designer

Six visual editors. Zero code.

Each designer produces YAML or BPMN files that the runtime reads at startup. Cross-designer discovery keeps everything in sync. Or skip the GUI — use AI skills to generate artifacts from natural language.

Org Config & Roles Editor

Visual tree editor with drag-and-drop, inline rename, and cycle detection
Add root Teams, child Teams, child groups, or link existing Teams for shared departments
11 app permissions per team — task, case, entity, document search, and tag management
Participant role editor with granular permissions across 5 categories (View, Content, Workflow, Management, Case)

Output: org-config/org-structure.yaml

BPMN Process Designer

Visual BPMN canvas with palette: events, gateways, user/service tasks, sub-processes
Candidate Groups tag picker populated from org hierarchy Teams
Form Key dropdown auto-discovers *.form.yaml from project
6 custom service task types: Send Email, Archive Documents, REST Service, SQL Query, Pleodox Task, External Worker
Outcome variables, variable promotion, multi-instance, async continuations

Output: processes/*.bpmn

Entity Schema Designer

Define entity types with fields, types, and display label templates
11 field types including TEXT, SELECT, REFERENCE, EMAIL, DATE, and more
Data source config for REST, LDAP, SQL, and YAML backends
Drag-and-drop field reordering, real-time validation

Output: entity-schemas/*.entity.yaml

Form Designer

Build process start/detail forms with 12 field types including FILE_UPLOAD
Bootstrap grid layout with col-4, col-6, col-8 width options
REFERENCE fields link to entity types discovered from project schemas
Required, placeholder, default value, hide-if-blank, editable flags

Output: process-forms/*.form.yaml

Case Type Designer

Define case types with icon, number prefix, numbering mode, and participant team/role assignments
Allowed processes populated from discovered BPMN files as checkboxes
Form and participant dropdowns populated from org-structure.yaml teams and roles
Validated at startup — allowed processes checked against deployed definitions

Output: case-types/*.case.yaml

Search Config Designer

Configure federated search across multiple backends — Alfresco CMIS and REST APIs
Visual UI config: global/advanced filters, metadata line, tags, view modes, and actions
SpEL expressions for dynamic metadata, conditional icons, and tag colors
Built-in actions: open URL, start process, start case — with per-result attachment binding

Output: search-configs/*.search.yaml

AI-Powered

Describe it. Generate it. Deploy it.

Pleodox Skills turn natural language into production-ready artifacts. Slash commands in Claude Code generate entities, forms, processes, and entire workflows from a single description.

Claude Code

$ /pleodox:create-workflow Contract approval with supplier lookup, finance sign-off, and email notification

+ entity-schemas/supplier.entity.yaml — 6 fields, JDBC data source

+ process-forms/contract-approval.form.yaml — 4 fields, REFERENCE to supplier

+ processes/contract-approval.bpmn — submit → gateway → approve/reject

+ case-types/contract-dispute.case.yaml — prefix CTR, linked form + process

+ org-config/org-structure.yaml — hierarchy, permissions, participant roles

5 files generated. All cross-references validated.

$ /pleodox:modify-process Add a 48h timer on the approval task that escalates to management

Timer boundary event added to "Approve Contract" with escalation path.

Entity

Form

Process

Case Type

Skills automatically resolve cross-references. Forms link to entities, processes bind to forms, cases reference processes.

/pleodox:create-workflow

Generate a complete workflow from a plain-language description — entities, forms, process, case type, and roles in one command.

/pleodox:create-entity

Define data models with typed fields, display templates, and optional external data sources (REST, LDAP, SQL).

/pleodox:create-form

Build process forms with field types, grid layout, validation rules, and entity REFERENCE lookups.

/pleodox:create-process

Design BPMN workflows with user tasks, gateways, timers, email notifications, and custom service tasks.

/pleodox:modify-process

Add tasks, gateways, timers, or error handling to existing processes. Describe the change, get valid BPMN.

/pleodox:list-resources

Scan the workspace, report all resources with cross-references, and flag broken links or missing dependencies.

/pleodox:create-search-config

Generate federated search configs — define Alfresco CMIS and REST engines, filters, metadata lines, tags, and actions.

Architecture

From design to deploy in one property

Studio writes artifacts to a workspace folder. The runtime reads them via app.external-resources. One property, all loaders pick up all artifact types.

Studio Designer

Org Config + Roles Editor

Schema Designer

Case Type Designer

Form Designer

Process Designer

Search Config Designer

Workspace Folder

org-config/org-structure.yaml

entity-schemas/*.entity.yaml

case-types/*.case.yaml

process-forms/*.form.yaml

processes/*.bpmn

search-configs/*.search.yaml

Runtime (Single JAR)

OrgStructure + RoleLoader

EntitySchemaLoader

CaseTypeLoader

ProcessFormLoader

Flowable BPMN Engine

FederatedSearchLoader

Single JAR Deploy

Spring Boot application — everything included. Run as a JAR, native executable, or shell application. One -Dapp.external-resources property points to the workspace.

Six Artifact Types

Org hierarchy (including participant roles), entity schemas, case types, process forms, BPMN processes, and federated search configs. Each has a dedicated loader with consistent pattern: scan classpath + external path, register in a typed registry.

Startup Validation

BPMN candidateGroups validated against org hierarchy Teams. Case allowedProcesses validated against deployed definitions. Directory schema fields checked for required contract.

Design your business processes visually. Deploy as a single JAR.

Everything you need to manage work

Organisational Hierarchy

Task Management

Case Management

Custom Entities

Process Forms

Participant Roles

Federated Search

Six visual editors. Zero code.

Org Config & Roles Editor

BPMN Process Designer

Entity Schema Designer

Form Designer

Case Type Designer

Search Config Designer

Describe it. Generate it. Deploy it.

From design to deploy in one property

Single JAR Deploy

Six Artifact Types

Startup Validation

Enterprise-ready out of the box

Directory Integration

Email Notifications

Pluggable Attachments

Ready to simplify your workflows?