Designing a Scalable Customer Service Solution Platform: Architecture, Workflow Engine, and Resource Engine

Introduction

The platform collects user issues from self‑service or human channels, records them, and returns standardized solutions. A unified solution platform integrates business information and service capabilities from multiple business units (BUs) to provide consistent answers for both human and intelligent channels.

Solution Platform Overview

Solutions are categorized into two types:

Dynamic Solutions (SOPs) : Process‑driven workflows such as unlocking a bike or handling a fee complaint. They enforce step‑by‑step handling.

Static Solutions : Knowledge‑base entries used for FAQs, rule explanations, and guidance.

Solution Matching : Maps user problems to one or more solutions.

Dynamic Solutions

Dynamic solutions standardize process guidance through form‑based interfaces that trigger backend business processes.

Link Diagram

Key design dimensions:

Support for multiple channel interaction methods.

Standardized process handling.

Efficient integration of business information and service capabilities.

Design is split into three layers:

Interaction : Various form types provide a consistent user experience across channels.

Process Management : A workflow engine drives step‑by‑step execution, allowing custom processes per scenario.

Resource Management : Forms and processes standardize data input; service capabilities are abstracted as resources (APIs and fields) managed by a resource engine.

Overall Functional Architecture

The configuration‑managed workflow enables end‑to‑end online design, testing, and deployment, shortening iteration cycles and improving product‑research efficiency. Visual workflow management supports quality control and risk mitigation, while a fully configurable self‑service chain improves iteration speed by roughly 60%.

Static Solutions

Static solutions deliver structured knowledge to users or assist agents (e.g., product FAQs, rule explanations, similar‑issue listings).

Overall Functional Architecture

Core requirements:

Support for structured and unstructured storage.

Search capabilities suitable for various scenarios.

The existing product relies on relational databases; upcoming upgrades will enhance storage, retrieval, and operational feedback functions.

Solution Matching

The matching layer links user problems to appropriate solutions across channels. Ideally each problem and each solution have a unique identifier, enabling a one‑to‑many mapping. In practice, problem descriptions are not unique and composite answers (static + dynamic) are often required. Future upgrades will support heterogeneous problem‑to‑answer group matching for greater scalability.

Technical Insights

Process Engine

After evaluating mature engines such as Activiti, gaps were found in deployment validation, data interaction, branching, performance, and maintenance cost for the specific scenario. A lightweight custom engine was built to provide stable, high‑performance core capabilities: driving workflow execution and exposing three primary interfaces— start, submit, and rollback.

Core Models

Process : Defines start, end, activities, paths, and execution strategies.

Process Elements : Nodes (events, tasks, gateways) and sequence flows.

Process Model : Complete description of element relationships.

Overall Design

Using the engine involves two steps: design a process and execute it. The architecture separates process definition from execution.

Process Definition

To keep running instances stable, the engine snapshots the process model at definition time and uses the snapshot during execution, ensuring independence from later model changes and simplifying operations.

Process Execution

Execution proceeds from a start node, processes the current node, determines the next node based on state and rules, and repeats until reaching an end node.

RuntimeProcessor : Initiates execution and handles task‑level interactions.

FlowExecutor : Drives node processing and manages instance state.

ElementExecutor : Handles individual node logic and state transitions.

Resource Engine

The platform must integrate numerous BU‑provided APIs (service capabilities). The resource engine abstracts these APIs as “resources” (APIs and fields) and offers a unified, configurable access layer.

Overall Design

Resources are classified as:

API : Service endpoints such as order‑detail queries.

Field : Individual data points returned by APIs (e.g., total amount).

The engine provides two main capabilities: resource definition retrieval and resource acquisition, organized into four modules:

Client SDK for fetching resources.

Server query service for high‑performance lookups.

Management console for configuration.

Quality‑data collection for usage metrics.

Interaction Model

System Architecture

Components:

Manager : Backend for resource configuration.

Server : High‑performance query service (access control + fast lookup).

Client : SDK that fetches resources.

Resource : Currently API‑type services, extensible to other types.

Resource Computation

The client SDK processes resources through layered components:

Protocol : Describes how callers use resources (e.g., GraphQL‑like syntax).

Processor : Core logic that (a) fetches resource definitions from the server, (b) computes an execution plan, (c) invokes BU APIs via a generic executor, and (d) transforms raw API data into final results.

Executor : Calls the actual BU capability based on the definition.

Example Dependency Graph

An illustrative graph shows how fields and APIs depend on each other. The engine resolves them through four stages:

Interpret : Parse the request and identify required resources.

Preprocess : Gather resource definitions and their dependencies.

Allocate : Group resources so that each group has internal dependencies but no external ones.

Process : Recursively fetch dependencies, invoke APIs, and apply transformers to produce final results.

Conclusion

The solution platform standardizes integration of business information and service capabilities, aligns answers across channels, and provides a visual management console. Future work will focus on automation and intelligence to further improve solution quality and support fine‑grained operations.