Decision Map & Reputation

Where the pay line sits, and what each choice teaches the crew

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

The decision map

The map below puts the board’s two unknowns on one picture: how long a restore would take (across) and what the crew demands (up). Below the line, paying is cheaper than restoring; above it, we should refuse. Move the slider to see how much the line depends on trust in our backups. The map describes the day-one choice, before any restore has been tried.

Figure 1: Decision map at the selected backup credibility. Amber: paying is cheaper. Blue: restoring is cheaper. Dashed gray: the boundary at the base credibility of 0.80.

How to read the plot. Restore time runs across the bottom and the crew’s demand runs up the side. The solid line is our walk-away point: the most it would be worth paying at each restore time. In the amber area below it, paying is cheaper; in the blue area above it, restoring is cheaper. The dashed gray line keeps the base case in view while you move the slider, and the black dot marks our firm today.

What the plot tells you. At the most likely input values, our firm’s dot sits just above its line: a $2.5M demand against a $2.39M walk-away point, a gap well inside the model’s uncertainty. Weaker backups push the line up and turn more demands into rational payments. Stronger backups and faster restores pull it down. Below about 2.3 days of restore time at base credibility, no demand is worth paying.

What each choice teaches the crew

Each incident is also a lesson for the crew. A crew that is paid concludes we value our systems more than it guessed, and asks for more next time. A crew that is refused lowers its estimate, and its next demand falls. We simulate a 10-year horizon in which the crew learns from every incident and favors targets that have paid before. For a firm that never pays, lower demands are not the benefit; the benefit is that a crew expecting less attacks less often.

We compare two policies. Pay when worth it means paying whenever, in that incident, the demand is below our walk-away point. Never pay means refusing every time, committed in advance.

Display code
base_grid <- at_p0(p0b)
dp <- bind_rows(
  tibble(series = "Never pay (any firm)", attack = 1:4, demand = rep$demand_seqs$R, policy = "never"),
  base_grid |> filter(policy == "rational", firm != "resilient") |>
    tidyr::pivot_longer(demand_1:demand_4, names_to = "attack", values_to = "demand") |>
    transmute(series = paste0(c(typical = "Our firm", fragile = "Fragile firm")[firm], ", pays when worth it"),
              attack = readr::parse_number(attack), demand, policy)
)
ends <- dp |> filter(attack == 4)
ggplot(dp, aes(attack, demand, color = policy, group = series)) +
  geom_line(aes(linetype = series), linewidth = 1.1) +
  geom_point(size = 2.8, color = "white") +
  geom_point(size = 2) +
  geom_text(data = ends, aes(label = series), hjust = 0, nudge_x = 0.08, size = 3.9, fontface = "bold") +
  scale_color_manual(values = POLICY_COLS, guide = "none") +
  scale_linetype_manual(values = c("solid", "solid", "22"), guide = "none") +
  scale_x_continuous("Attack number", breaks = 1:4, limits = c(1, 5.6)) +
  scale_y_continuous("Crew's demand", labels = \(x) paste0("$", x, "M"), limits = c(0, 5)) +
  labs(title = "Refusing pulls the next demand down; paying pushes it up",
       subtitle = "Average demand at each successive attack ($M)")
Three lines over attacks one to four. Never pay falls steadily. Our firm, paying when worth it, stays roughly flat. The fragile firm, paying when worth it, rises with each attack.
Figure 2: Average demand the crew posts at each successive attack, by firm and policy, at a 15% annual attack rate.

How to read the plot. Each line follows the crew’s demand from the first attack to the fourth. The blue line is a firm that never pays; because the crew learns only from refusals, its path is the same for any firm. The orange lines are firms that pay when the demand is below their walk-away point: dashed for our firm, solid for the fragile one. Points are averages over the simulated paths that reach each attack.

What the plot tells you. Refusal teaches the crew that we are a poor prospect: its demand falls from $2.53M to $0.87M by the third attack. The fragile firm, which pays almost every time, sees demands climb to $4.59M by the fourth. In one survey, 78% of payers were attacked again and 63% of those were asked for more, though it does not compare payers with non-payers (Infosecurity Magazine, February 2024).

Ten years of cost

How often we expect to be attacked is the input the board is least sure of, so the chart below lets you set it.

Figure 3: Expected 10-year cost by firm profile and policy at the selected annual attack rate. Labels give expected attacks over 10 years. The resilient firm never pays under either policy, so it is shown once.

How to read the plot. Each row is a firm profile: resilient (4-day restore, 0.90 backup credibility), our firm (10 days, 0.80) and fragile (21 days, 0.60). Blue dots are never pay; orange dots pay when worth it. The resilient firm never pays under either policy, so it has one gray dot. Each label gives the expected 10-year cost and expected number of attacks. Drag the slider to change the annual chance of an attack.

What the plot tells you. At 15%, never paying saves our firm about $2.4M and the fragile firm about $5.9M over 10 years. The saving comes from fewer attacks: 2.2 in 10 years for the fragile firm if it pays when worth it, against 1.2 if it never pays. The saving grows quickly with the attack rate. The resilient firm would refuse every demand anyway, so for it the policy costs nothing to keep.

The more often you expect to be attacked, the more a reputation for refusing is worth. At a 5% annual rate, the fragile firm is slightly better off paying case by case (by $1.2M over 10 years), because it is rarely attacked often enough for reputation to matter. From about 9% upward, never paying is cheaper for both firms.

Why the policy must be credible

A no-pay policy is only worth what the crew believes about it, and a policy breaks under pressure when breaking it pays. In the moment, a fragile firm facing the first $2.53M demand saves about $4.8M by paying, because its walk-away point is $6.87M.

To test whether that temptation should win, we compare never paying with paying once, at the first incident, and never again. Costs are in present value at a 8% discount rate, so the saving on the day counts in full and later attacks count for less. For the fragile firm, paying once costs $16.2M over 10 years against $14.0M for never paying: the extra attacks it invites outweigh the saving, so the policy is credible, by a margin of $2.2M. For our firm the margin is $1.3M. If crews ignore past payments, the result reverses: paying once saves the fragile firm $3.2M, and the policy is not credible.

A resilient firm faces no such test. Its walk-away point is −$0.67M, so refusing is also its cheapest move on the day. Its policy is believed because it never has to be enforced against its own interest. Resilience is what turns a stated policy into a believed one.

The assumption everything rests on

Display code
rep$eta |>
  filter(eta %in% unlist(P$reputation$eta_table)) |>
  select(eta, firm, policy, cost_10y) |>
  tidyr::pivot_wider(names_from = c(firm, policy), values_from = cost_10y) |>
  gt() |>
  cols_label(eta = "Targeting response (η)",
             typical_rational = "Pay when worth it", typical_never = "Never pay",
             fragile_rational = "Pay when worth it", fragile_never = "Never pay") |>
  tab_spanner("Our firm", starts_with("typical")) |>
  tab_spanner("Fragile firm", starts_with("fragile")) |>
  fmt_number(columns = -eta, decimals = 1) |>
  fmt_number(columns = eta, decimals = 2) |>
  tab_style(cell_text(weight = "bold"),
            cells_body(columns = typical_never, rows = typical_never < typical_rational)) |>
  tab_style(cell_text(weight = "bold"),
            cells_body(columns = typical_rational, rows = typical_rational < typical_never)) |>
  tab_style(cell_text(weight = "bold"),
            cells_body(columns = fragile_never, rows = fragile_never < fragile_rational)) |>
  tab_style(cell_text(weight = "bold"),
            cells_body(columns = fragile_rational, rows = fragile_rational < fragile_never)) |>
  cols_align("center", -eta) |>
  gt_board()
Table 1: Expected 10-year cost ($M) by how strongly crews favor firms that have paid before, at a 15% annual attack rate.
Targeting response (η)
Our firm
Fragile firm
Pay when worth it Never pay Pay when worth it Never pay
0.00 15.2 16.2 17.6 24.9
0.25 15.2 15.2 19.0 23.4
0.50 15.3 14.4 20.9 22.2
1.00 15.6 13.2 26.2 20.3

How to read the table. Each row sets how strongly crews favor firms that have paid before. Zero means they don’t care; one means a firm whose expected payout is twice as high is attacked twice as often. Each cell is the expected 10-year cost for one firm and policy, in $M. The cheaper policy in each row and firm is in bold.

What the table tells you. With no targeting response, paying when worth it is always cheaper, because it is the best choice in each incident by construction. Never paying wins once crews favor known payers: above about 0.24 for our firm and 0.59 for the fragile firm. The whole reputation benefit rests on this one behavioral assumption. If crews ignore past payments, the case for never paying must rest on other grounds, such as sanctions risk.

The case for a no-pay reputation rests on attackers favoring known payers. Industry surveys show that many payers are attacked again, but they do not report how often non-payers are, so the strength of this effect is unmeasured. It is the model’s most important assumption.