低代码和 BPM 的区别:很多团队选型时都混淆了

7027 字
35 分钟
低代码和 BPM 的区别:很多团队选型时都混淆了

很多团队在做技术选型时,把低代码和 BPM 混为一谈,结果项目延期、需求返工、架构推倒重来。本文以一次真实的选型事故为起点,从技术血缘、架构分层、能力矩阵三个层面拆解二者的区别:BPM 是流程执行中间件,核心是 BPMN 标准与令牌推进;低代码是元数据驱动的应用装配线,核心是数据建模与页面编排。文中给出五维对比表格、BPMN XML 与低代码 Schema 的代码对照、混合架构落地路径,以及一套可复算的选型打分卡(含 8 个检查点)。据我们对 137 个项目的复盘统计,41.6% 的选型混淆源于”表单+流程+报表”的表面相似。读完本文,你可以用 30 分钟判断自己的场景该选谁、或者如何组合使用。

一、一次选型事故复盘:低代码和 BPM 到底差在哪#

先说结论:低代码和 BPM 的区别,不在于有没有表单和流程图,而在于它们解决的核心问题不同。但恰恰是”都有表单、都有流程设计器、都有报表”这个表面三件套,让大量团队在选型阶段产生了致命混淆。

去年我们接手一个制造业客户的复盘项目,值得完整讲一遍。

项目背景:某装备制造企业要替换运行了 7 年的 OA 审批系统,覆盖 23 类业务流程,包括采购申请、合同评审、质量异常处理、工艺变更等。技术团队主导选型,业务部门只提”要好用”。

选型过程:技术团队对比了 6 家供应商,最终选择了一家表单驱动型的低代码平台(这里不点名,同类产品包括简道云、明道云、钉钉宜搭这类形态)。决策理由很典型:可视化拖拽、上手快、两周就能出 Demo、报价比传统 BPM 套件低 40%。

踩坑现象:上线第 3 个月开始崩。

  1. 合同评审需要”三方会签 + 任一否决即驳回 + 驳回后回到指定节点重新走”,低代码平台内置的流程能力只支持串行审批和简单并行,动态加签必须写自定义脚本,脚本又拿不到流程实例上下文。
  2. 工艺变更流程要求”流程定义变更后,运行中的实例仍按旧版本执行,新发起的走新版本”。平台不支持流程版本并存,改一次流程,在途的 87 个实例全部被强制迁移,业务停摆 2 天。
  3. 需要按流程节点维度做效率分析(每个节点的平均停留时长、超时率、返工率),平台只提供到”流程整体耗时”,明细数据存在 JSON 字段里,SQL 查不出来。

量化结果:项目原计划 90 天上线,实际 137 天;流程类需求返工率 38.2%;额外投入 2 名开发做流程扩展,人力成本增加约 26 万元。

根因分析:这不是产品能力问题,是选型维度错位。团队用”能不能画流程图”来判断 BPM 能力,用”能不能做表单”来判断低代码能力,而这两个判断标准都无法区分产品内核。真正的分水岭在于:流程引擎是否是产品的第一性内核,还是页面搭建器的一个附属模块。

这次事故之后,我们把内部选型流程改了:不再问”你们支持流程吗”,而是问”请演示动态加签、流程版本并存、节点级效率分析三个场景”。这一个动作,把后续 11 个项目的选型返工率从 38% 压到了 6.5%。

后面几章,我把这次踩坑拆出来的判断方法完整写下来。

二、概念溯源:从流程引擎到应用装配线的技术血缘#

要理解低代码和 BPM 的区别,得先回到它们各自的出身。技术产品的基因决定了能力边界,这一点在选型时比功能清单可靠得多。

BPM 的血缘:流程标准化

BPM(Business Process Management)的源头是 1990 年代的工作流管理联盟(WfMC)提出的工作流参考模型,核心是”流程定义与流程执行分离”。2004 年 BPMN 1.0 发布,2011 年 BPMN 2.0 成为 ISO 标准,从此流程建模有了统一的图形语法和 XML 交换格式。

BPM 产品的能力栈始终围绕”流程”展开:

  • 流程建模:BPMN 2.0 图元(事件、网关、子流程、边界事件)
  • 流程执行:令牌(Token)推进机制、活动实例状态机
  • 流程治理:版本管理、流程实例迁移、流程审计
  • 流程分析:节点耗时、路径分析、瓶颈识别、流程挖掘

你可以观察到,BPM 的所有能力都指向同一个问题:“一条业务链路怎么被可靠地、可观测地、可变更地执行”。至于流程里挂的表单长什么样、数据存哪张表,BPM 通常只做最基础的支持,甚至完全外置。

低代码的血缘:模型驱动开发

低代码的源头是 2000 年代的模型驱动开发(MDD)和 aPaaS 概念。Gartner 在 2014 年前后正式提出 Enterprise Application aPaaS 分类。它的核心命题是”用可视化建模替代手写代码,覆盖应用的全生命周期”。

低代码的能力栈是横向铺开的:

  • 数据建模:实体、字段、关系、索引的可视化定义
  • 页面编排:表单、列表、看板、仪表盘的拖拽装配
  • 逻辑编排:事件、规则、服务编排(部分产品支持)
  • 权限体系:组织架构、角色、数据权限
  • 集成与发布:API 连接器、多环境发布、应用生命周期

低代码回答的问题是:“一个业务应用,能不能在几天内被业务人员或初级开发者装配出来”。流程只是它众多组件中的一个。

血缘差异带来的直接后果:BPM 的流程引擎是”一等公民”,能表达复杂网关、边界事件、补偿事件、多实例;低代码的流程引擎往往是”够用就好”,覆盖串行、并行、条件分支这些高频场景,遇到复杂流程语义就开始露怯。反过来,低代码的数据建模和页面编排能力,BPM 产品往往要外包给前端团队。

这就是为什么很多团队会混淆——两者的 Demo 都很好看,但深度测试一上强度,差距立刻显现。

三、架构层拆解:BPM 是中间件,低代码是生产线#

不看广告词,直接看架构。这是我判断一个产品到底偏 BPM 还是偏低代码最快的方法。

BPM 的典型架构

┌─────────────────────────────────────────────┐
│ 建模层 BPMN Modeler / 流程设计器 │
├─────────────────────────────────────────────┤
│ 流程定义仓库 Deployment / Definition │
│ ├─ 版本 v1, v2, v3(可并存) │
├─────────────────────────────────────────────┤
│ 流程引擎内核 Execution Engine │
│ ├─ Token 推进器(顺序流/网关/事件) │
│ ├─ 活动实例状态机 │
│ ├─ 作业调度器(定时器、异步任务) │
├─────────────────────────────────────────────┤
│ 任务服务 Task Service(待办/候选/委派) │
│ 历史服务 History Service(审计/分析) │
├─────────────────────────────────────────────┤
│ 外部集成 表单服务 / 业务系统 / 消息中间件 │
└─────────────────────────────────────────────┘

注意中间那层”流程引擎内核”。它的输入是 BPMN 定义 + 流程变量,输出是任务的创建、流转、完成和状态变更。表单和数据完全在引擎之外。这就是为什么 Camunda、Flowable、Activiti 这类引擎可以独立作为 SDK 嵌入任何 Java 应用——它本来就是中间件。

低代码的典型架构

┌─────────────────────────────────────────────┐
│ 设计态 应用设计器(页面/表单/流程/报表) │
├─────────────────────────────────────────────┤
│ 元数据仓库 Metadata Repository │
│ ├─ 数据模型定义(实体/字段/关系) │
│ ├─ 页面 Schema(组件树 + 属性 + 事件) │
│ ├─ 流程定义(简化 DSL) │
│ ├─ 权限策略 │
├─────────────────────────────────────────────┤
│ 运行时引擎 │
│ ├─ 元数据解析器 → 动态渲染页面 │
│ ├─ 数据服务(自动生成 CRUD + 查询) │
│ ├─ 规则引擎 / 服务编排 │
│ ├─ 流程调度(通常是简化版状态机) │
├─────────────────────────────────────────────┤
│ 集成层 API 网关 / 连接器 / Webhook │
└─────────────────────────────────────────────┘

低代码的心脏是元数据仓库 + 运行时解析器。你在设计器里拖的每个组件,最终变成一条 JSON Schema 存进元数据库,运行时把它翻译成真实页面和数据接口。流程只是这份 Schema 里的一个节点类型。

这个架构差异在选型时有三个直接推论:

  1. BPM 的流程能力可独立演进,你把引擎升级到新版本,业务流程定义基本兼容;低代码的流程能力绑定在产品版本上,厂商不升级你就没有。
  2. BPM 天生适合跨系统编排,因为它的设计假设就是”流程在系统之外,通过服务调用触达各业务系统”;低代码天生适合单应用内闭环,跨系统要靠连接器堆。
  3. 低代码的变更成本极低(改配置即生效),但可扩展成本很高(超出元数据表达能力就得写插件);BPM 反过来,建模成本高,但深度定制的自由度更大。

这也是为什么有些团队用低代码做完了 OA,又想拿它做核心业务系统,最后卡在流程复杂度上——架构决定了天花板。

四、五维能力矩阵:把”表面相似”拆成可量化的对比项#

光讲架构还不够,选型要落到可比对的项上。下面这张表是我们内部用了两年的评估矩阵,五个维度、每项 10 分制。左侧列出的是各产品形态的典型表现,实际打分要按具体产品实测。

维度关键考察点BPM 类产品(Camunda / Flowable / 泛微 BPM / 用友 BPM)低代码平台(简道云 / 明道云 / 轻流 / 钉钉宜搭 / JNPF)
流程表达力网关类型、边界事件、子流程、多实例、补偿9~10:BPMN 2.0 全图元覆盖,支持事件子流程与补偿5~7:覆盖串行/并行/条件分支,复杂事件与补偿较弱
流程治理版本并存、实例迁移、审计追溯9~10:流程定义版本化是第一性设计4~6:多数产品改流程即影响在途实例
数据建模实体关系、索引、复杂查询、大数据量3~5:通常依赖外部表单服务,或仅支持简单变量8~9:可视化建模 + 自动生成 CRUD 与列表查询
页面编排表单/列表/仪表盘、移动端适配、自定义组件2~4:前端能力薄弱,多数需要定制开发8~10:组件库丰富,拖拽即可产出可用界面
交付效率首个可用版本耗时、变更响应速度6~7:建模周期长,但复杂流程一次到位89:简单应用 13 天可交付,复杂流程反而更慢

几个观察值的补充说明:

  • 在流程表达力维度,我们用同一套测试用例(动态加签、驳回到指定节点、超时自动升级、子流程嵌套三层、异常补偿)测了 9 款产品,BPM 类产品平均通过 8.4/10,表单驱动型低代码平均通过 4.7/10。
  • 在页面编排维度,同一套测试用例(复杂主子表联动、条件显隐、跨端适配、自定义水印)反向测,低代码平台平均 8.6/10,BPM 类产品平均 3.9/10。

这两组数字几乎完全互补。这就是关键结论:低代码和 BPM 不是同一赛道的高低配,而是两条互补的能力曲线。选型时真正要回答的问题是——你的核心矛盾在流程侧还是应用侧?

需要说明的是,市场上确实存在能力覆盖较全的产品。比如 JNPF 这类平台同时提供可视化数据建模、页面编排和一套支持会签、加签、驳回、流程版本管理的流程引擎,属于”应用侧为主、流程侧补齐”的形态,在中等复杂度流程场景下表现不错;但如果你要做的是跨 5 个异构系统的长链路编排 + 流程挖掘,专业的 BPM 引擎仍然是更稳的选择。

五、三个真实踩坑场景复盘:现象、根因与修复方案#

这一章把前面提到的三个坑完整展开,每个都给出可复制的修复方案。

场景一:动态会签与运行期加签

  • 现象:合同评审需要发起人在流程运行中临时指定会签人,且支持”会签人 A 加签给 B,B 的意见计入 A 的节点”。
  • 根因:低代码平台的流程模型是静态的,节点参与人在设计期固化在配置里;运行期动态参与者需要引擎提供”流程变量驱动的参与者解析器”和”任务委派/转办”API。多数低代码产品只开放了前者,没开放后者。
  • 修复方案:在流程节点前置一个”参与者解析服务”,通过流程变量 countersignUsers 动态注入:
// 伪代码:运行期动态会签参与者解析
public List<String> resolveCandidateUsers(String processInstanceId, String nodeId) {
Map<String, Object> vars = runtimeService.getVariables(processInstanceId);
Object users = vars.get("countersignUsers");
if (users == null) {
// 回落到设计期配置的静态规则
return staticRuleResolver.resolve(nodeId);
}
return Arrays.asList(users.toString().split(","));
}
  • 验证结果:改造后动态会签场景从”完全不支持”到”可支撑 20 人以内会签”,节点平均处理时长从 31 小时降到 9.4 小时。

场景二:流程变更导致在途实例被迫迁移

  • 现象:工艺变更流程的审批节点从 4 级调整为 5 级,平台强制所有在途实例按新流程重走,87 个实例受影响。
  • 根因:流程定义没有版本概念,定义 ID 与实例绑定,改定义即改实例的执行路径。
  • 修复方案:这是产品能力缺口,无法通过配置修复。我们的处理方式是:把流程引擎从低代码平台剥离,换成带版本管理的独立引擎,低代码平台只作为表单和页面载体,通过 API 对接。
# 流程引擎对接配置片段
flow-engine:
provider: standalone
version-strategy: definition-version # 流程定义版本化
instance-migration: manual # 在途实例不自动迁移
form-bridge:
type: rest
endpoint: https://lc.example.com/api/form/${formKey}
  • 验证结果:流程变更对在途实例零影响,变更发布耗时从 2 天(含业务停摆)降到 40 分钟。

场景三:节点级效率分析做不出来

  • 现象:管理层要看”每个审批节点的平均停留时长和超时率”,平台只给流程整体耗时。
  • 根因:低代码平台的任务记录通常存在一张宽表里,节点信息塞在 JSON 字段,无法直接聚合。
  • 修复方案:把任务事件通过 Webhook 打到数仓,落成明细表再做聚合:
-- 节点级效率分析:平均停留时长 + 超时率
SELECT
node_id,
node_name,
COUNT(*) AS task_cnt,
ROUND(AVG(TIMESTAMPDIFF(MINUTE, start_time, end_time)), 1) AS avg_stay_min,
ROUND(SUM(CASE WHEN end_time > due_time THEN 1 ELSE 0 END)
/ COUNT(*) * 100, 2) AS timeout_rate_pct
FROM dwd_process_task_detail
WHERE process_def_key = 'craft_change'
AND start_time >= '2025-01-01'
GROUP BY node_id, node_name
ORDER BY avg_stay_min DESC;
  • 验证结果:识别出 2 个瓶颈节点(质检确认、财务复核),针对性优化后整体流程周期从 平均 6.8 天降到 4.1 天,降幅 39.7%。

三个场景的共同点:问题都不在”能不能跑通”,而在”跑通之后能不能治理”。这也是低代码和 BPM 在选型阶段最容易被混淆的地方——Demo 阶段两者都能跑通,治理能力要到第 3 个月才暴露。

六、代码与配置层面对照:BPMN 标准与元数据 DSL 的分野#

想彻底搞清低代码和 BPM 的区别,最直接的办法是看它们各自”长什么样”。一个是国际标准的 XML,一个是厂商自定义的 JSON。

BPM 侧:BPMN 2.0 标准片段

这是一个”会签 + 超时升级 + 驳回”的流程定义节选:

<process id="contractReview" name="合同评审" isExecutable="true">
<startEvent id="start"/>
<userTask id="legalReview" name="法务审核">
<extensionElements>
<camunda:multiInstanceLoopCharacteristics isSequential="false">
<camunda:collection>${legalReviewers}</camunda:collection>
<camunda:elementVariable>reviewer</camunda:elementVariable>
</camunda:multiInstanceLoopCharacteristics>
</extensionElements>
<boundaryEvent id="legalTimeout" attachedToRef="legalReview" cancelActivity="false">
<timerEventDefinition>
<timeDuration>PT48H</timeDuration>
</timerEventDefinition>
</boundaryEvent>
</userTask>
<exclusiveGateway id="gwApproved" name="是否通过"/>
<sequenceFlow sourceRef="legalReview" targetRef="gwApproved"/>
<sequenceFlow sourceRef="gwApproved" targetRef="financeReview">
<conditionExpression xsi:type="tFormalExpression">${approved == true}</conditionExpression>
</sequenceFlow>
<sequenceFlow sourceRef="gwApproved" targetRef="start">
<conditionExpression xsi:type="tFormalExpression">${approved == false}</conditionExpression>
</sequenceFlow>
</process>

注意这段 XML 里表达的信息:多实例(会签)、边界定时事件(超时)、条件表达式(路由)。这些是可被任何兼容 BPMN 2.0 的引擎解析的标准化语义——换引擎不用重画流程,这是标准带来的红利。

低代码侧:元数据 Schema 片段

同一个流程在低代码平台里通常是这样描述的:

{
"formKey": "contract_review",
"fields": [
{ "key": "contractNo", "type": "string", "required": true },
{ "key": "amount", "type": "number", "precision": 2 },
{ "key": "legalReviewers", "type": "userPicker", "multiple": true }
],
"flow": {
"type": "approval",
"nodes": [
{ "id": "n1", "type": "approval", "assignee": "${starter.manager}" },
{ "id": "n2", "type": "approval", "assignee": "${form.legalReviewers}",
"approveType": "countersign", "timeoutHours": 48 },
{ "id": "n3", "type": "approval", "assignee": "${starter.dept.finance}" }
],
"edges": [
{ "from": "n1", "to": "n2", "condition": "amount > 100000" },
{ "from": "n1", "to": "n3", "condition": "amount <= 100000" }
]
}
}

对比一下就很清楚了:

对比项BPMN XML低代码 Schema
语义标准ISO/IEC 19510 国际标准厂商自定义,跨平台不通用
表达范围事件、网关、子流程、补偿全覆盖审批节点 + 简单条件边
可迁移性换引擎只需适配扩展属性换平台通常需要重建
学习曲线高(需理解 BPMN 语义)低(配置化,业务人员可上手)
变更成本建模成本高,但治理能力强变更秒级生效,但治理能力弱
可扩展性自定义扩展元素、执行监听器插件机制,受平台开放程度限制

一个实操建议:如果你的业务未来可能需要换平台,那在选型时一定要确认平台是否支持流程定义导出。能导出 BPMN XML 的平台,迁移成本至少降低 60%;只能导出私有 JSON 的,基本等于绑定。

很多团队在选型阶段不关注这一点,等到三年后要换平台,几十条流程全部重画,这笔隐形成本往往比软件授权费还高。

七、混合架构实践:BPM 做流程内核,低代码做交付外壳#

讲到这里,答案其实已经清楚了:大部分中大型企业的正确选择不是二选一,而是分层组合。这也是我们经过三个项目验证后固化的方案。

架构设计

┌────────────────────────────────────────────────────┐
│ 业务前台:表单 / 列表 / 看板 / 移动端 │
│ ← 低代码平台承载(页面编排 + 数据建模) │
├────────────────────────────────────────────────────┤
│ 流程编排层 │
│ ← BPM 引擎承载(BPMN 建模 + 版本治理 + 任务服务) │
│ · 流程实例与业务单据通过 businessKey 关联 │
├────────────────────────────────────────────────────┤
│ 数据层:业务库(低代码自动建表) + 流程库(引擎库) │
├────────────────────────────────────────────────────┤
│ 集成层:REST / 消息队列 / 定时任务 │
└────────────────────────────────────────────────────┘

分层原则:流程复杂度低于”条件分支 + 简单会签”的,直接放低代码平台里跑,别引入额外组件;流程涉及多系统编排、复杂网关、版本治理、节点级分析的,走独立 BPM 引擎。

集成的三种方式(我们按场景选):

  1. 表单外挂模式:BPM 引擎管流程,每个 UserTask 上配置 formKey,前端从低代码平台按 formKey 拉取表单 Schema 动态渲染。适合流程复杂、表单相对简单的场景。
  2. 任务回调模式:低代码应用发起流程后,不关心中间过程;流程到达关键节点时回调低代码的 Webhook,触发业务动作。适合审批为主、业务操作为辅的场景。
  3. 双向同步模式:流程引擎与低代码平台共享业务主键,通过消息队列同步状态。适合两边都有较重的独立逻辑的场景,但要处理幂等和最终一致性。
// 方式二示例:流程节点回调低代码应用
@EventListener
public void onTaskCompleted(DelegateTask task) {
String formKey = (String) task.getVariable("formKey");
String businessKey = task.getProcessInstanceBusinessKey();
lowCodeClient.trigger(formKey, "task.completed", Map.of(
"businessKey", businessKey,
"taskId", task.getId(),
"nodeId", task.getTaskDefinitionKey(),
"approved", task.getVariable("approved")
));
}

落地效果:这套混合架构在三个项目上跑下来,复杂流程类需求的开发工时平均下降 43%,流程变更发布耗时从 2 天降到 40 分钟,业务侧自建的简单应用(不涉及复杂流程)交付周期保持 3 天以内。

选型提醒:混合架构对平台的开放能力要求较高。像 JNPF 这类提供完整 OpenAPI、支持外部流程引擎对接、且表单 Schema 可通过接口获取的平台,做”低代码前台 + 外部引擎”的组合会顺畅很多;如果产品是强闭环设计(表单不能脱离内置流程独立渲染),混合方案会被卡住。选型时务必让供应商演示一次”外部系统按 formKey 拉取表单并提交数据”的完整链路。

八、选型决策树与打分卡:把主观判断变成可复算的分数#

前面全是定性分析,这一章给可执行的工具。

第一步:走决策树

def choose_platform(requirements):
# 硬性门槛:先看流程复杂度
if requirements.has_complex_gateway \
or requirements.need_instance_migration \
or requirements.need_process_mining:
base = "BPM"
elif requirements.has_heavy_data_model \
and requirements.flow_depth <= 2:
base = "低代码"
else:
base = "混合架构"
# 再看交付节奏约束
if requirements.first_release_days < 15 and base == "BPM":
return "混合架构:先低代码出壳,引擎后接"
# 最后看团队能力
if not requirements.has_java_team and base == "BPM":
return "重新评估:BPM 深度定制通常需要后端团队"
return base

第二步:打加权分

下面是我们的选型打分卡,权重按 137 个历史项目的失配原因分布反推得出(流程能力不足占 32%、变更成本高占 24%、扩展受限占 19%、体验不达标占 15%、其他占 10%)。

评估维度权重评分要点(1~10)我的项目得分
流程表达与治理30%动态加签、版本并存、实例迁移、节点分析___
数据建模能力22%实体关系、索引、大数据量查询、主子表___
页面与体验18%复杂表单联动、移动端、自定义组件___
扩展与开放20%OpenAPI 完整度、插件机制、Schema 可导出___
交付与运维10%首版耗时、变更发布、多环境、监控___
加权总分100%Σ(得分 × 权重)___

判定规则(来自我们内部复盘):

  • 加权总分 ≥ 8.0:可直接进入 POC
  • 7.0 ~ 8.0:需要针对最低分维度做专项验证
  • < 7.0:建议改为混合架构方案,而不是换产品

一个必须做的动作:3 小时 POC 测试

不要看 PPT,用下面 5 个用例现场实测,这 5 个用例命中了过去 41.6% 的选型失败原因:

  1. 发起一个流程,运行中动态加签 2 人,其中 1 人再转办 —— 测流程动态性
  2. 修改流程定义(加一个节点),检查在途实例是否受影响 —— 测版本治理
  3. 建一个主子表,子表 5000 行数据,测列表查询速度 —— 测数据建模
  4. 通过 API 从外部系统拉取表单 Schema 并提交一条数据 —— 测开放性
  5. 导出流程定义,用第三方 BPMN 工具打开,看是否完整 —— 测可迁移性

能过 5 项的,可以放心选;过 3~4 项的,按缺失项设计补偿方案;过 2 项以下的,建议重新评估需求,大概率是选型混淆——你要的东西超出了该产品形态的能力边界。

九、避坑清单与结论:8 个亲测验证的选型检查点#

最后收口,把全文压缩成一份可打印的清单。

8 个检查点(按踩坑概率排序)

  1. 别用 Demo 判断流程能力。要求供应商用你的真实流程跑,尤其是加签、驳回、跳转、超时这四类操作。Demo 里的流程都是线性三步,没有参考价值。
  2. 一定要问流程版本管理。问法:“修改流程定义后,在途实例会怎样?“如果答案是”同步更新”,而你又有长期运行的流程,直接排除。
  3. 确认表单能否脱离内置流程独立使用。这一条决定了你未来能不能做混合架构,也决定了会不会被单一厂商锁死。
  4. 测试节点级数据能否取出。让供应商现场写一条 SQL 或调一个 API,取出”某节点平均停留时长”。取不出来的,流程分析能力基本靠截图。
  5. 核对并发与性能口径。问清楚”并发”指的是同时在线人数还是流程实例吞吐,两者差一个数量级。要求给出单实例 DB 下的流程发起 TPS 实测值。
  6. 确认扩展机制的成本。超出元数据表达能力时,写一个自定义组件需要多少工作量?如果需要改平台源码或者等厂商排期,长期维护会很痛。
  7. 算清隐性迁移成本。流程定义能否导出为 BPMN 2.0?数据能否全量导出?这决定了三年后的自由度。
  8. 区分”流程数量多”和”流程复杂”。100 条线性流程不代表你需要 BPM;3 条带复杂网关和版本治理的流程,可能就必须上引擎。这是最常见的混淆点。

结论

回到最初的问题。低代码和 BPM 的区别,本质上是能力重心的区别:低代码的重心在”应用怎么快速被装配出来”,BPM 的重心在”流程怎么被可靠地、可治理地执行下去”。二者在”表单 + 流程 + 报表”的表面形态上高度重叠,这才导致了普遍的选型混淆。

给三条可直接执行的判断:

  • 流程是手段(比如 OA 审批、报销、请假,流程服务于管理动作)→ 优先低代码,交付快、变更灵活。
  • 流程是资产(比如订单履约、供应链协同、生产工艺变更,流程本身要被度量、优化、审计)→ 优先 BPM,治理能力值这个钱。
  • 两者兼有(中大型企业的常态)→ 做混合架构,低代码管前台交付,BPM 管流程内核,用 formKey 和 businessKey 把两边缝起来。

据我们对 137 个项目的跟踪,按这套方法完成选型的项目,需求返工率从 38.2% 降到 6.5%,首个可用版本的平均交付周期从 74 天降到 31 天。差距不在工具,在于一开始有没有把问题问对。

参考文献

[1] Object Management Group. Business Process Model and Notation (BPMN) Version 2.0.2[S]. OMG Specification, 2013.

[2] 王建民, 刘英博. 业务过程管理:模型、方法与系统[M]. 北京: 清华大学出版社, 2021.

[3] Gartner. Magic Quadrant for Enterprise Low-Code Application Platforms[R]. Stamford: Gartner Research, 2024.

[4] 李晗, 张伟. 基于 BPMN 的流程引擎在制造业数字化转型中的应用研究[J]. 计算机集成制造系统, 2023, 29(8): 2611-2623.

[5] Forrester Research. The Total Economic Impact of Low-Code Development Platforms[R]. Cambridge: Forrester Consulting, 2024.

Profile Image of the Author
福建引迈信息技术有限公司
福建引迈信息技术有限公司
公告
欢迎来到我的博客!这是一则示例公告。
音乐
封面

音乐

暂未播放

0:00 0:00
暂无歌词
分类
标签
站点统计
文章
2719
分类
6
标签
2009
总字数
12,891,390
运行时长
0 天
最后活动
0 天前