Assumptions, sensitivity, limitations and checks

All money is in $M and all values are illustrative.

This page records what the analysis assumes, how much the answer moves when those assumptions change, and the checks that the numbers are computed correctly. It is the place to start before using any figure from this site in a real decision.

Assumptions register

Display code
rng <- \(v) paste(unlist(INPUT_SPEC[[v]]$par)[c(1, 3)], collapse = "–")
values <- c(
  c = sprintf("$%gM per day (range %s)", BASE$c, rng("c")),
  T_r = sprintf("%g days (range %s)", BASE$T_r, rng("T_r")),
  b = sprintf("%.2f (Beta(8, 2))", BASE$b),
  q = sprintf("%.2f (Beta(17, 3))", BASE$q),
  s = sprintf("%.2f (Beta(2, 18)); penalty %g × ransom", BASE$s, BASE$kappa),
  `p_np|p_p` = sprintf("%.2f if we refuse; %.2f if we pay", BASE$p_np, BASE$p_p),
  prior = sprintf("Median $%gM, log-sd %g; incident-to-incident log-sd %g", bp$prior_median, bp$prior_sdlog, bp$incident_sdlog),
  eta = sprintf("%g (tested %g to %g)", P$reputation$eta_base, min(ETA_FINE), max(ETA_FINE)),
  p0 = sprintf("%s a year (%s to %s on the slider)", fmt_pct(P$reputation$p0_base), fmt_pct(min(P0_GRID)), fmt_pct(max(P0_GRID))),
  posted = "One take-it-or-leave-it demand per incident",
  crew = sprintf("One crew over %d years", P$reputation$years)
)
readr::read_csv(file.path(PROJECT_ROOT, "data", "assumptions_register.csv"), show_col_types = FALSE) |>
  mutate(value = values[param]) |>
  select(id, assumption, value, basis, owner, review_trigger) |>
  gt() |>
  cols_label(id = "ID", assumption = "Assumption", value = "Value", basis = "Basis",
             owner = "Owner", review_trigger = "Review trigger") |>
  cols_width(id ~ px(50), value ~ px(200)) |>
  gt_board()
Table 1: Assumptions register. Each assumption has an owner and a trigger for review.
ID Assumption Value Basis Owner Review trigger
A1 Outage cost per day $0.5M per day (range 0.25–0.9) Firm assumption: lost revenue, client SLA credits, overtime and churn CFO Annual budget cycle or a change in client contracts
A2 Restore time from backups 10 days (range 3–30) Firm assumption, set against Sophos 2025 (53% of victims recovered within a week) CIO Every restore test; any major platform change
A3 Backup credibility 0.80 (Beta(8, 2)) Firm assumption CISO Every restore test; any backup failure
A4 Decryptor works 0.85 (Beta(17, 3)) Firm assumption CISO Incident-response retainer briefing on the active crew
A5 Sanctions nexus 0.10 (Beta(2, 18)); penalty 1 × ransom Firm assumption; OFAC 2021 advisory on sanctions risk General Counsel New OFAC designations or guidance
A6 Leak probabilities 0.80 if we refuse; 0.60 if we pay Firm assumption; re-extortion after payment (The Register, Proofpoint data) as directional support CISO New industry data on leaks after payment
A7 Crew's prior belief Median $2.5M, log-sd 0.7; incident-to-incident log-sd 0.4 Firm assumption at the high end of published figures (Sophos 2025 median demand $1.32M; Coveware Q3 2026 median payment $400K) CISO Threat-intelligence update on demand levels
A8 Targeting response 1 (tested 0 to 1.5) Firm assumption; direction suggested but not measured by repeat-attack surveys Chief Risk Officer Any evidence on how crews pick repeat targets
A8b Annual attack rate 15% a year (5% to 25% on the slider) Illustrative; no sourced base rate, so readers set it on page 3 Chief Risk Officer Threat-intelligence or insurer loss data
A9 Posted demand (no haggling) One take-it-or-leave-it demand per incident Simplification; negotiated discounts make this conservative Incident-response lead Policy review
A10 Single crew One crew over 10 years Simplification; one crew learns from our history Chief Risk Officer Evidence of shared intelligence among crews

How to read the table. Each row is one assumption the results depend on. The value column gives the number used and, where relevant, the range tested. The basis says whether it is a firm judgment, a simplification, or anchored to a published source. The owner is the executive who should sign off on the value, and the review trigger is the event that should prompt an update.

What the table tells you. Almost every input is a judgment that the firm would replace with its own figures. The two that matter most are restore time (A2) and backup credibility (A3), both of which a restore test can measure directly. The targeting response (A8) and the attack rate (A8b) drive the reputation result and have the weakest evidence behind them.

Sensitivity

Display code
sens$oat |>
  select(label, low, high, R_low, R_high, swing) |>
  gt() |>
  cols_label(label = "Input", low = "Low value", high = "High value",
             R_low = "Walk-away at low ($M)", R_high = "Walk-away at high ($M)", swing = "Swing ($M)") |>
  fmt_number(columns = c(low, high), n_sigfig = 2) |>
  fmt_number(columns = c(R_low, R_high, swing), decimals = 2) |>
  tab_spanner("Input range", c(low, high)) |>
  gt_board()
Table 2: Walk-away point when one input moves to its 10th or 90th percentile, all others at base. Base walk-away point $2.39M.
Input
Input range
Walk-away at low ($M) Walk-away at high ($M) Swing ($M)
Low value High value
Restore time 7.3 23 1.57 6.30 4.73
Backup credibility 0.63 0.94 4.01 1.04 2.97
Decrypt and validate time 4.6 9.7 2.91 0.97 1.94
Rebuild time if backups fail 28 50 1.83 3.55 1.72
Outage cost per day 0.38 0.74 1.87 3.40 1.53
Payment delay 2.0 4.8 2.84 1.58 1.26
Leak cost 2.6 7.7 2.14 3.05 0.92
Decryptor works 0.74 0.94 1.95 2.76 0.81
Leak probability, pay 0.48 0.68 2.81 2.08 0.72
Leak probability, refuse 0.68 0.88 1.96 2.67 0.71
Fixed cost of paying 0.40 1.1 2.48 1.81 0.67
Sanctions nexus 0.028 0.19 2.55 2.21 0.35

How to read the table. Each row moves one input from a low value to a high value: the points below which 10% and 90% of its range fall. Everything else stays at base. The next two columns give the walk-away point at each end, and the swing is the gap between them. Rows are sorted with the biggest swing at the top.

What the table tells you. Restore time moves the walk-away point by $4.73M, more than any other input, followed by backup credibility at $2.97M. Better information on both, for example from a full restore test, is the most valuable input the board can buy. Decrypt and validate time, which the crew’s tooling sets, is the third-largest swing: even after paying, the platform stays down for about 9 days at base.

Display code
cal |>
  gt() |>
  cols_label(case = "Ranges", T_r_median = "Median restore (days)", T_r_range = "Restore range (days)",
             b_mean = "Average backup credibility", R_median = "Median walk-away ($M)", pay_share = "Pay share") |>
  fmt_number(columns = T_r_median, decimals = 1) |>
  fmt_number(columns = c(b_mean, R_median), decimals = 2) |>
  fmt_percent(columns = pay_share, decimals = 0) |>
  gt_board()
Table 3: Share of simulated incidents in which paying is the cheaper path, under this firm’s ranges and under market-typical restore times.
Ranges Median restore (days) Restore range (days) Average backup credibility Median walk-away ($M) Pay share
This firm's ranges 13.6 3–30 0.80 3.45 65%
Market calibration 5.0 1.1–11.1 0.90 −0.81 9%

How to read the table. Each row is a Monte Carlo run of 200,000 simulated incidents, each with its own inputs and a random demand. The first row uses this firm’s ranges. The second shrinks restore times so that the median is 5 days and makes backups work about 90% of the time. The last column is the share of incidents in which paying is cheaper than restoring.

What the table tells you. With this firm’s ranges, paying is the cheaper path in 65% of incidents; with faster restores and stronger backups, in 9%. Reported market payment rates lie between the two runs, so the model brackets the market rather than matching it. The high first figure reflects this firm’s slow restores: the same model with market-like recovery pays far less often.

The simulated pay share is high because this firm restores slowly: its median restore time is 13.6 days, against roughly a week for most victims (Sophos 2025). At the base demand of $2.5M, paying on day one is cheaper in 64% of draws. The market payment rate was 23% in Q3 2025 (Coveware), fell to a new record low in Q2 2026 (Coveware), and nearly 80% of Q3 2026 incidents were resolved without payment (Coveware). That rate lies between the two runs, about 2.5 times the market-calibration figure. Observed payment rates also reflect insurance, law-enforcement involvement and corporate policy, which this model leaves out.

Display code
sbs <- mc$shares_by_sdlog
sbs |>
  filter(input %in% c("E_T", "T_r", "b", "D")) |>
  mutate(input = factor(input, levels = c("E_T", "T_r", "b", "D"))) |>
  select(sdlog, pay_share, input, share) |>
  tidyr::pivot_wider(names_from = input, values_from = share) |>
  gt() |>
  cols_label(sdlog = "Demand spread (log-sd)", pay_share = "Pay share", E_T = "Expected outage time",
             T_r = "Restore time", b = "Backup credibility", D = "Ransom demand") |>
  tab_spanner("Share of variation in the pay decision", c(E_T, T_r, b, D)) |>
  fmt_number(columns = sdlog, decimals = 1) |>
  fmt_percent(columns = c(pay_share, E_T, T_r, b, D), decimals = 0) |>
  gt_board()
Table 4: Share of the variation in the pay-or-not decision explained by each input, as the spread of demands widens. The median demand and all other draws are held fixed.
Demand spread (log-sd) Pay share
Share of variation in the pay decision
Expected outage time Restore time Backup credibility Ransom demand
0.6 65% 39% 23% 9% 15%
1.0 61% 27% 16% 6% 31%
1.4 57% 19% 12% 4% 43%

How to read the table. Each row reruns the 200,000 simulated incidents with demands spread more or less widely around the same median. The first column measures that spread: 0.6 is the site’s moderate assumption, and 1.4 is closer to the spread of published payments across all victims. The next column is how often paying is cheaper. The rest show how much of the yes-or-no decision each input explains on its own.

What the table tells you. The ranking flips as demands vary more widely. At the moderate spread, expected outage time explains 39% of the decision and the demand 15%; at the widest, the demand explains 43%. What holds at every spread is structural: restore time sets the walk-away point, and the demand only tests it. The pay share also falls as demands spread out, because more of them land far above the walk-away point.

Limitations

  • Synthetic firm. Every cost and probability is illustrative; a real decision needs the firm’s own outage cost, restore-test results and leak exposure.
  • Posted demand. The crew names one price. Negotiated discounts exist, so treating the demand as final overstates the cost of paying.
  • No cyber insurance. Insurance would cover part of the outage and possibly the ransom, which shifts the walk-away point.
  • One crew. The model has a single crew that learns from our history. Several crews, or crews that share intelligence, would change how fast reputation builds.
  • Leak cost is fixed. It does not depend on the number or sensitivity of the records taken.
  • The targeting response is uncertain. The reputation result holds only if crews favor known payers: above about 0.24 for our firm and 0.59 for the fragile firm; see the Decision Map & Reputation page.
  • The crew learns about our walk-away point, not our policy. A firm that never pays looks like one with a low walk-away point, so its demand keeps falling instead of the crew moving on.
  • The staged path needs time. Restoring first and paying only if backups fail assumes the firm can negotiate while restoring; leak deadlines or rising demands can remove that option.
  • Sanctions are a cost, not a bar. A known sanctions link would rule out payment entirely rather than add a penalty.
  • Outage cost is constant per day. In practice client churn accelerates after the first week, which would make restore time matter even more.
  • The decryptor works fully or not at all. Partial decryption would leave some restore effort even after paying.

Diagnostics

Display code
diag |>
  gt() |>
  cols_label(check = "Check", result = "Result", detail = "Detail") |>
  tab_style(cell_text(color = "#1a7f37", weight = "bold"), cells_body(columns = result, rows = result == "Pass")) |>
  tab_style(cell_text(color = "#b42318", weight = "bold"), cells_body(columns = result, rows = result != "Pass")) |>
  gt_board()
Table 5: Checks run by the pipeline on every build.
Check Result Detail
Closed form vs simulation Pass 2,000,000 event draws: refuse cost within 0.03%, pay cost within 0.01%; mean gap -0.127 vs closed form -0.125 (3 s.e. = 0.011)
Indifference at the walk-away point Pass |C_pay(R*) − C_refuse| = 0.0e+00
Monotonicity Pass R* rises with restore time, rebuild time, outage cost and decryptor reliability; falls with backup credibility, payment delay, fixed cost of paying and sanctions risk
JavaScript–R parity (slider 1) Pass b = 0.60, 0.80, 0.95: max difference 4.4e-16
Attack-rate grid Pass Year-1 attack probability equals p0 in all 126 runs; never-pay attacks at or below 10 × p0 (largest ratio 0.92); cost and attacks rise with p0 for all six firm–policy pairs
Smoothness across p0 Pass Largest step is 1.37 × the median step (limit 3)
Seed stability Pass Variance shares differ by at most 0.003 across 5 seeds
Driver ranking Pass Expected outage time ranks first for R* in 5 of 5 seeds
Reputation direction Pass Demand after successive refusals: 2.53 → 1.35 → 0.87 → 0.61; fragile firm, rational: 2.53 → 3.33 → 4.00 → 4.59
Belief normalization Pass Max |sum of weights − 1| = 1.8e-15 over 135 belief states
Discounting Pass Present-value cost at or below the undiscounted cost for all 12 policy runs (discount rate 8%)
Deviate once with no targeting response Pass With η = 0, paying once costs no more than never paying: typical −$0.39M; fragile −$4.36M

How to read the table. Each row is one automatic check that runs every time the analysis is rebuilt. The result column shows whether it passed, and the detail column gives the evidence: the size of any error, the number of cases checked, or the values compared. A failure stops the build, so a published page should never show one.

What the table tells you. 12 of 12 checks pass. The formula matches an event-by-event simulation, the interactive map uses exactly the same formula as the R code, the simulation results move smoothly as the attack rate changes, and the main ranking of drivers does not depend on the random seed. Together they show that the numbers follow from the stated assumptions; they cannot show that the assumptions are right.

To rebuild everything, run Rscript R/run_all.R and then quarto render; the Reproducibility page has the full steps.

References