Code-less Business Process Orchestration: Design, Implementation, and Application

In business‑driven development, frequent requirement changes and complex approval processes increase scheduling risk and deployment difficulty; developers also face heterogeneous coding styles that hinder code comprehension. The proposed solution abstracts business logic into a drag‑and‑drop, configurable orchestration layer, reducing manual coding and improving agility.

Traditional static compilation (e.g., Go binaries) ties code to fixed packages and makes dependency management painful. By treating the workflow as a graph rather than a call stack, the system decouples business logic from implementation, allowing dynamic scheduling similar to state‑machine languages.

The core concepts include Node (a reusable task), Edge (a boolean condition analogous to switch‑case), and a StateMachine that connects nodes via edges. Contextual input/output, logging, tracing, and metrics are encapsulated in messages, enabling clear data flow and fault isolation.

The architecture consists of three modules: a scheduling engine, a trigger component, and business workers. Workers register with a server cluster via an SDK, while an etcd‑based dynamic configuration center (DCC) watches for real‑time changes to ensure strong consistency across the distributed system.

Key Go data structures are defined as follows:

type PlayBook struct {
    lock sync.Mutex `json:"-"`
    ttl ttl `json:"-"`
    ttlEnable bool `json:"-"`
    startAt string `json:"-"`
    validated bool `json:"-"`
    Id int
    States map[string]*Node
}

type Node struct {
    NodeName string
    NodeCode string
    Description string
    EdgesOfCondition edges
    Task *Task
}

type Edge struct {
    Description string
    NextNode string
    Express string
    Priority int
}

type Message struct {
    Meta MetaImpl `json:"Meta"`
    Task TaskImpl `json:"Task"`
    Context ContextImpl `json:"Context"`
}

type Context struct {
    Filter int8 `json:"Filter"`
    TTL ttl `json:"TTL,omitempty"`
    Last interface{} `json:"Last"`
    Store map[string]interface{} `json:"Store"`
    Exception *Exception `json:"Exception,omitempty"`
}

type Event struct {
    // definitions omitted for brevity
}

type XesRn struct {
    Service ServiceType
    Region string
    AccountID string
    Name string
}

The edge expression parser converts ASL‑style expressions into executable DSL objects: func (e *Edge) ParseAslExpress(message *Message) (result []*dsl.Expression, token dsl.Token) { // implementation parses logical operators and replaces variables with runtime values } The DCC watch loop monitors etcd changes and triggers configuration reloads: for i := range watchChan { for _, e := range i.Events { // handle PUT and DELETE events, reload state machine if version changes } } Application examples include a simple arithmetic workflow (ADD, SUB, MUL, DIV) implemented as Go workers registered via the SDK, and triggered either programmatically or via HTTP curl. Visual dashboards display normal (green) and error (red) paths, confirming that all context data is observable and auditable. A second case demonstrates integration with a data‑consumption layer, where incoming records are split, parsed, and routed to appropriate downstream tasks based on type, illustrating the framework’s extensibility. In summary, by converting code into a visual state‑machine model, the platform achieves clearer architecture, easier maintenance, and scalable distributed execution, laying the groundwork for future enhancements in workflow orchestration.