以下人物、公司与数字均为教学假设,不构成对任何真实产品的评价。
试点通过之后,团队最常问的问题是「什么时候可以扩到全量」。这个问题看起来是时间问题,实际是风险问题:同样扩到 40% 的用户,如果这 40% 里包含大量不可逆动作,暴露面可能比 100% 的只读检查更大。
所以放量的单位不是用户数,也不是任务数,而是风险暴露量。风险暴露量由三个因子相乘:覆盖的任务数、动作本身的危险程度、以及出错后能不能收回。这一节先把动作分成三档,再用 C Runner 的 5%、20%、60% 说明为什么不可逆动作必须最后放。
用户数为什么不是放量单位
假设两个团队都决定「先放 10% 的用户」。A Relay 放的是 10% 的工单分诊建议,机器只给建议,人确认后才生效;C Runner 放的是 10% 的运营任务,机器会直接改价、下架、发通知。两者的用户比例相同,风险暴露量差了一个数量级。
用户数只描述「谁在用」,不描述「机器能做什么」。真正决定风险的是动作:只读检查错了,最多是漏看;改价错了,会直接影响成交;发通知错了,客户已经收到,撤不回来。
| 放量单位 | 回答的问题 | 什么时候会骗人 |
|---|---|---|
| 用户数 | 多少人能用 | 用户少但动作危险时,风险被低估 |
| 任务数 | 多少任务被处理 | 任务多但都是只读时,风险被高估 |
| 风险暴露量 | 多少危险动作被执行 | 需要先给动作分层,计算成本更高 |
风险暴露量不是要取代用户数和任务数,而是给它们加一个权重。用户数回答「覆盖面」,风险暴露量回答「最坏情况有多大」。放量决策应该同时看两个数:覆盖面决定学习速度,暴露量决定能不能承受一次事故。
风险分层的四个维度
分层不能只看「这个动作重不重要」,那太主观。可以用四个可观察的维度:
| 维度 | 低风险 | 中风险 | 高风险 |
|---|---|---|---|
| 可逆性 | 完全可回滚 | 需要人工介入才能回滚 | 不可回滚 |
| 客户可见性 | 内部可见 | 客户能看到结果 | 客户已经收到且无法撤回 |
| 资金影响 | 无直接资金变化 | 影响后续结算 | 直接改动价格或退款 |
| 审计有效性 | 全量可判断 | 抽样可判断 | 事后难以判断对错 |
四个维度里,可逆性权重最高。一个动作只要不可逆,不管它看起来多小,都应该先按高风险处理。C Runner 的错误中 86% 可回滚,14% 不可回滚;不可回滚错误率是 1.7% × 14% = 0.238%。这个比例看起来很小,但乘以 13,200 个任务,每个月仍有约 31.4 个不可回滚错误。这个数字不是可以靠「再观察一周」消化的。
第二个重点是客户可见性。内部可见的错误可以内部消化,客户可见的错误会变成投诉,客户已经收到的错误会变成补偿。三者对应三套处理流程,不能共用同一个放量阈值。
三档动作与进入顺序
把四个维度合成三档,得到一个足够简单的规则:
| 档位 | 判定 | 典型动作 | 进入阶段 |
|---|---|---|---|
| 低风险 | 可逆、内部可见、无资金影响、全量可审计 | 只读检查、生成内部摘要 | 5% 阶段 |
| 中风险 | 可逆、客户可见,或抽样可审计 | 改库存、下架、改展示文案 | 20% 阶段 |
| 高风险 | 不可逆,或直接改动资金 | 改价、退款、发客户通知 | 60% 阶段达标之后 |
这个规则不追求精确,追求的是顺序稳定。只要顺序稳定,团队就不会在事故后争论「这个动作算不算高风险」;规则已经提前写好了。
C Runner 的三级放量正好对应这个顺序:
| 阶段 | 覆盖 | 时长 | 允许的动作 | 退出条件 |
|---|---|---|---|---|
| 影子 | 100% 只记录 | 4 周 | 不执行 | 与人工决策一致率 ≥ 85% |
| 执行 5% | 5% 任务 | 4 周 | 低风险 | 错误率 ≤ 2%,零不可回滚错误 |
| 执行 20% | 20% 任务 | 8 周 | 低 + 中风险 | 错误率 ≤ 1.8%,回滚成功率 100% |
| 执行 60% | 60% 任务 | 8 周 | 不含高风险 | 连续 8 周达标 |
注意 60% 阶段仍然「不含高风险」。高风险动作不是在第 60% 阶段顺便放开的,而是在 60% 阶段连续达标之后单独决策。这个细节经常被漏掉:团队看到「60%」就以为只剩 40% 的收尾,实际上最危险的那部分还没有开始。
暴露量怎么算
把风险暴露量写成一个可计算的数:
暴露量 = 覆盖任务数 × 风险档权重
覆盖任务数 = 月任务量 × 覆盖率
权重不是精确的科学常数,而是把「低、中、高」的相对危险程度显式化。一个可用的起点是 1、3、12:高风险动作的错误代价大约是低风险的十二倍。团队可以根据自己的事故记录调整权重,但一旦定下,就要在所有放量评审里用同一套。
以 C Runner 为例:
| 阶段 | 覆盖率 | 覆盖任务数 | 允许档位 | 暴露量 |
|---|---|---|---|---|
| 执行 5% | 5% | 660 | 低 | 660 |
| 执行 20% | 20% | 2,640 | 低 + 中 | 10,560 |
| 执行 60% | 60% | 7,920 | 低 + 中 | 31,680 |
| 全量 | 100% | 13,200 | 低 + 中 + 高 | 211,200 |
从 5% 到 20%,覆盖任务数变成 4 倍,暴露量变成 16 倍;从 20% 到 60%,覆盖任务数变成 3 倍,暴露量变成 3 倍。这个非线性来自档位权重:20% 阶段第一次引入中风险动作,暴露量的跳变应该被看见,而不是只看到「覆盖率从 5% 到 20%」。
不可逆动作为什么必须最后放
不可逆动作的风险不是「错误率更高」,而是「错误的后果不能被时间修复」。可逆动作错了,回滚就是一次操作;不可逆动作错了,只能补偿,而补偿的成本通常高于预防。
C Runner 的 14% 不可回滚动作主要是已发出的客户通知。通知发错了对象或内容,反向执行没有意义,只能补发说明并安排人工回访。事实表把这类动作单列出来,就是为了让放量计划把它们排在最后。
| 动作 | 可逆 | 客户可见 | 资金影响 | 档位 | 放量位置 |
|---|---|---|---|---|---|
| 只读检查 | 是 | 否 | 否 | 低 | 5% |
| 改库存 | 是 | 是 | 否 | 中 | 20% |
| 下架 | 是 | 是 | 否 | 中 | 20% |
| 改价 | 是 | 是 | 是 | 高 | 60% 达标后 |
| 发客户通知 | 否 | 是 | 否 | 高 | 60% 达标后 |
这张表还有一个用途:当团队想「先放一个高风险动作试试」时,可以直接指出它跳过了两个阶段。跳过阶段不是绝对禁止,但必须有单独的风险评审和回滚演练记录,不能混在常规放量里。
把分层写成可执行模型
下面的模型把动作分类、阶段上限、档位准入和暴露量放在一起。它的输出不是「能不能放」,而是「这个阶段最多覆盖多少、哪些档位被允许、暴露量是多少」。
// file: src/rollout/11-1-risk-tiers.ts
// tier: L2
// verify: node --test test/rollout/11-1-risk-tiers.test.ts
// 放量单位不是用户数,而是风险暴露量:
// 月任务量 × 覆盖率 × 该风险档的权重。
// 不可逆动作排在最后,不是因为难,而是因为错了没法收回。
import { RUNNER } from "../cases.ts";
import { applyRate, FULL, type Bps } from "../core/rate.ts";
export type RiskTier = "low" | "medium" | "high";
export type Stage = "shadow" | "execute-5" | "execute-20" | "execute-60" | "full";
export type ActionClass = {
readonly name: string;
readonly reversible: boolean;
readonly customerVisible: boolean;
readonly financialImpact: boolean;
readonly auditBps: Bps;
};
// 先看能不能收回,再看影响面,最后看审计能不能判对错。
export function classify(action: ActionClass): RiskTier {
if (!action.reversible || action.financialImpact) return "high";
if (action.customerVisible) return "medium";
if (action.auditBps < 8_000) return "medium";
return "low";
}
export const TIER_WEIGHT: Record<RiskTier, number> = {
low: 1,
medium: 3,
high: 12,
};
export const STAGE_CAP_BPS: Record<Stage, Bps> = {
shadow: 0,
"execute-5": 500,
"execute-20": 2_000,
"execute-60": 6_000,
full: FULL,
};
// 低风险在 5% 阶段进入,中风险在 20%,高风险要等 60% 阶段连续达标之后。
export const ADMIT_AT: Record<RiskTier, Stage> = {
low: "execute-5",
medium: "execute-20",
high: "full",
};
const STAGE_RANK: Record<Stage, number> = {
shadow: 0,
"execute-5": 1,
"execute-20": 2,
"execute-60": 3,
full: 4,
};
export function admittedAt(tier: RiskTier, stage: Stage): boolean {
return STAGE_RANK[stage] >= STAGE_RANK[ADMIT_AT[tier]];
}
export type StagePlan = {
readonly stage: Stage;
readonly capBps: Bps;
readonly admitted: readonly RiskTier[];
readonly excluded: readonly RiskTier[];
readonly exposedTasks: number;
readonly exposure: number;
};
export function planStage(monthlyTasks: number, stage: Stage): StagePlan {
const tiers: readonly RiskTier[] = ["low", "medium", "high"];
const admitted = tiers.filter((tier) => admittedAt(tier, stage));
const excluded = tiers.filter((tier) => !admittedAt(tier, stage));
const exposedTasks = applyRate(monthlyTasks, STAGE_CAP_BPS[stage]);
const exposure = admitted.reduce(
(sum, tier) => sum + exposedTasks * TIER_WEIGHT[tier],
0,
);
return {
stage,
capBps: STAGE_CAP_BPS[stage],
admitted,
excluded,
exposedTasks,
exposure,
};
}
// 同一阶段里,风险越高的动作应该占总量的比例越低。
export function shareWithinStage(tier: RiskTier, stage: Stage): Bps {
if (!admittedAt(tier, stage)) return 0;
const total = (["low", "medium", "high"] as const)
.filter((t) => admittedAt(t, stage))
.reduce((sum, t) => sum + TIER_WEIGHT[t], 0);
return Math.round((TIER_WEIGHT[tier] / total) * FULL);
}
export function rolloutOrder(actions: readonly ActionClass[]): readonly string[] {
const rank: Record<RiskTier, number> = { low: 0, medium: 1, high: 2 };
return actions
.slice()
.sort(
(a, b) =>
rank[classify(a)] - rank[classify(b)] || a.name.localeCompare(b.name),
)
.map((action) => action.name);
}
export const RUNNER_ACTIONS: readonly ActionClass[] = [
{
name: "read-only check",
reversible: true,
customerVisible: false,
financialImpact: false,
auditBps: 9_500,
},
{
name: "stock update",
reversible: true,
customerVisible: true,
financialImpact: false,
auditBps: 9_000,
},
{
name: "delist",
reversible: true,
customerVisible: true,
financialImpact: false,
auditBps: 9_000,
},
{
name: "price change",
reversible: true,
customerVisible: true,
financialImpact: true,
auditBps: 9_000,
},
{
name: "send customer notice",
reversible: false,
customerVisible: true,
financialImpact: false,
auditBps: 9_000,
},
];
export const C_STAGES: readonly Stage[] = [
"shadow",
"execute-5",
"execute-20",
"execute-60",
"full",
];
export function runnerStagePlan(stage: Stage): StagePlan {
return planStage(RUNNER.monthlyTasks, stage);
}
模型里有两个刻意的选择。第一,classify 先判断 reversible 和 financialImpact,再看客户可见性和审计有效性;这是把「能不能收回」放在「影响大不大」前面。第二,ADMIT_AT 把高风险动作放在 full,而不是 execute-60;这对应事实表里「执行 60% 不含高风险动作」的口径。
shareWithinStage 是一个辅助判断:在同一个阶段里,高风险动作的权重占 75%,中风险占 18.75%,低风险占 6.25%(全量阶段)。这不是要求动作数量按这个比例分配,而是提示评审者:一旦高风险动作进入,它就会主导暴露量。
放量评审要问的四个问题
有了模型,放量评审可以固定问四个问题:
- 这一阶段允许哪些档位的动作?被排除的档位有没有偷偷混进来?
- 覆盖率乘以月任务量,实际覆盖多少任务?
- 按当前权重,暴露量是多少?和上一阶段比,跳变是否可解释?
- 如果今天出现一次最坏情况,回滚或补偿能不能在承诺时间内完成?
四个问题里,第四个最容易被跳过。团队通常能说清「放多少」,说不清「出事后多久能恢复」。而恢复能力才是放量的真正上限:恢复不了的动作,放 1% 也是太多。
小结
- 放量单位不是用户数,也不是任务数,而是风险暴露量。
- 风险分层看四个维度:可逆性、客户可见性、资金影响、审计有效性。
- 可逆性权重最高;不可逆动作不管多小,都先按高风险处理。
- 低风险在 5% 阶段进入,中风险在 20%,高风险要等 60% 阶段连续达标之后。
- C Runner 的 5%、20%、60% 不是三个百分比,而是三次风险档位的扩容。
- 暴露量 = 覆盖任务数 × 风险档权重;20% 阶段第一次引入中风险,暴露量会跳变。
- 不可逆动作必须最后放;C 的 14% 不可回滚动作对应 0.238% 的不可回滚错误率。
- 放量评审要同时回答覆盖多少、暴露多少、出事后多久能恢复。
阅读导航:上一节:10.3 试点的退出条件 · 下一节:11.2 回滚触发条件 。
常见错误与边界
- 按用户数放量。 同样 10% 的用户,只读检查和改价的风险差一个数量级;用户数不描述机器能做什么。
- 把高风险动作混进 60% 阶段。 事实表的 60% 明确「不含高风险动作」;高风险要在 60% 连续达标后单独决策。
- 只算覆盖率,不算暴露量。 5% 到 20% 覆盖任务数变 4 倍,暴露量可能变 16 倍;跳变必须被看见。
- 权重经常改。 权重可以调整,但同一轮放量评审必须用同一套;否则阶段之间不可比。
- 跳过阶段做「小范围试试」。 跳过阶段不是绝对禁止,但要有单独的风险评审和回滚演练记录。
- 不问恢复时间。 恢复不了的动作,放 1% 也是太多;放量上限最终由恢复能力决定。
下一节把「什么时候回滚」写成三类触发条件:指标阈值、单一严重事件、人工判断权。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。