Skip to main content

​
What It Does

Decision Shield translates regime assessments into operator-safe guidance. It evaluates high-stakes decisions—hiring, roadmap changes, pricing moves—against current conditions and returns a simple verdict:

SAFE

Execute with normal guardrails

RISKY

Proceed with extra scrutiny

DANGEROUS

Delay or redesign the decision
Every verdict includes:
  • Sensor bullets: Base rate, curve slope, and regime scores
  • Guardrail: Execution checklist tied to measurable milestones
  • Reversal trigger: Specific conditions to revisit the decision

​
Input Categories

Decision Shield requires three inputs to evaluate any decision:

​
1. Lifecycle Stage

lib/decisionShield.ts
export type LifecycleStage = "DISCOVERY" | "GROWTH" | "SCALE" | "MATURE";
Early-stage, pre-product-market fit
  • High burn sensitivity
  • Capital-intensive actions carry extra risk
  • Focus on survival and validation

​
2. Decision Category

lib/decisionShield.ts
export type DecisionCategory =
  | "HIRING"
  | "ROADMAP"
  | "PRICING"
  | "INFRASTRUCTURE"
  | "M_AND_A"
  | "GEOGRAPHIC_EXPANSION"
  | "RESTRUCTURING";
Team expansion, new roles, contractor-to-FTE conversions
Feature launches, platform rewrites, technical debt paydown
Discounts, packaging changes, tier restructuring
Cloud spend, tooling upgrades, compliance investments
Acquisitions, divestitures, asset sales
New regions, localization, international GTM
Org changes, cost reduction, operational pivots

​
3. Decision Action

lib/decisionShield.ts
export type DecisionAction =
  | "HIRE"
  | "REWRITE"
  | "LAUNCH"
  | "DISCOUNT"
  | "EXPAND"
  | "ACQUIRE"
  | "DIVEST"
  | "INFRA_SPEND"
  | "REGIONAL_EXPANSION"
  | "RESTRUCTURE";
Each action maps to a specific label:
lib/decisionShieldConfig.ts
export const DECISION_ACTION_LABELS: Record<DecisionAction, string> = {
  HIRE: "Hire",
  REWRITE: "Rewrite",
  LAUNCH: "Launch",
  DISCOUNT: "Discount",
  EXPAND: "Expand",
  ACQUIRE: "Acquire",
  DIVEST: "Divest",
  INFRA_SPEND: "Infra spend",
  REGIONAL_EXPANSION: "Regional expansion",
  RESTRUCTURE: "Restructure",
};

​
Verdict Matrix

Decision Shield uses a deterministic verdict matrix mapping actions to regimes:
lib/decisionShieldConfig.ts
export const DECISION_VERDICT_MATRIX: Record<
  DecisionAction,
  Record<RegimeKey, DecisionVerdict>
> = {
  HIRE: {
    SCARCITY: "DANGEROUS",
    DEFENSIVE: "RISKY",
    VOLATILE: "RISKY",
    EXPANSION: "SAFE",
  },
  REWRITE: {
    SCARCITY: "DANGEROUS",
    DEFENSIVE: "SAFE",      // Efficiency play
    VOLATILE: "RISKY",
    EXPANSION: "SAFE",
  },
  ACQUIRE: {
    SCARCITY: "DANGEROUS",
    DEFENSIVE: "RISKY",
    VOLATILE: "RISKY",
    EXPANSION: "SAFE",
  },
  DIVEST: {
    SCARCITY: "SAFE",       // Preserve cash
    DEFENSIVE: "SAFE",
    VOLATILE: "RISKY",
    EXPANSION: "RISKY",     // Growth mode
  },
  // ... (full matrix in source)
};
Contextual adjustments: Discovery-stage teams get verdict escalation for capital-intensive actions. Mature teams get de-escalation for restructuring moves.

​
Real Examples

​
Example 1: Hiring in SCARCITY

const input: DecisionInput = {
  lifecycle: "GROWTH",
  category: "HIRING",
  action: "HIRE",
  context: "Expanding sales team by 5 reps",
};

const assessment = evaluateRegime(treasury); // Returns SCARCITY regime
const output = evaluateDecision(assessment, input);
DANGEROUS verdicts suggest delaying or redesigning the decision. If you must proceed, implement the guardrail checkpoints and monitor for reversal triggers.

​
Example 2: Platform Rewrite in DEFENSIVE

const input: DecisionInput = {
  lifecycle: "SCALE",
  category: "ROADMAP",
  action: "REWRITE",
  context: "Migrate monolith to microservices",
};

const assessment = evaluateRegime(treasury); // Returns DEFENSIVE regime
const output = evaluateDecision(assessment, input);
SAFE verdicts mean the decision aligns with regime constraints. Execute with the provided guardrail milestones.

​
Example 3: Acquisition in EXPANSION

const input: DecisionInput = {
  lifecycle: "SCALE",
  category: "M_AND_A",
  action: "ACQUIRE",
  context: "Acquiring complementary SaaS product",
};

const assessment = evaluateRegime(treasury); // Returns EXPANSION regime
const output = evaluateDecision(assessment, input);
EXPANSION regimes create rare windows for aggressive M&A. Still, demand integration milestones—guardrails prevent execution drift.

​
Guardrails

Every action has a pre-defined guardrail with measurable checkpoints:
lib/decisionShieldConfig.ts
export const DECISION_GUARDRAILS: Record<DecisionAction, string> = {
  HIRE: "Phase hiring in 30-day tranches; each cohort must show payback traction within 120 days via booked revenue or verified cost reduction.",
  
  REWRITE: "Ship rewrite milestones every 45 days and continue only while release throughput trends at least 1.5x above baseline.",
  
  LAUNCH: "Launch behind staged rollouts (10%→50%→100%) and continue only while churn and ARPA stay at or above pre-launch trend over the first 60 days.",
  
  DISCOUNT: "Use discount windows capped at 30 days and pair each concession with annual prepay, multi-year term, or measurable expansion rights.",
  
  EXPAND: "Expand in waves and hold each wave unless support SLA, retention, and margin stay within 5% of baseline for two consecutive monthly reads.",
  
  ACQUIRE: "Advance only with an integration plan that shows leading KPI lift inside 90 days and clear payback path inside 12 months at current burn.",
  
  DIVEST: "Execute with signed transition owners and service continuity checkpoints every 30 days until revenue retention stabilizes.",
  
  INFRA_SPEND: "Release infrastructure spend in milestones and continue only when unit-cost or SLA gains are visible within the first 90 days.",
  
  REGIONAL_EXPANSION: "Open regions in pilot mode first; scale only after two consecutive monthly cohorts hit demand, activation, and support readiness thresholds.",
  
  RESTRUCTURE: "Proceed in sequenced phases and continue only while runway extends by at least one quarter without breaching delivery commitments.",
};
Guardrails are execution contracts, not suggestions. They prevent unchecked burn and ensure decisions remain reversible.

​
Copy-Ready Output

Decision Shield outputs are designed for easy sharing:
1

Generate verdict

Run evaluateDecision(assessment, input) to get structured output
2

Copy to clipboard

Use the UI copy button or programmatically extract output.summary
3

Share in planning docs

Paste verdict summary, bullets, and guardrail into PRDs, roadmap docs, or Slack threads
4

Set calendar reminders

Parse output.reversalTrigger to schedule regime re-checks (30-day default)

​
Usage Example

import { evaluateRegime } from "@/lib/regimeEngine";
import { evaluateDecision } from "@/lib/decisionShield";
import type { DecisionInput } from "@/lib/decisionShield";

// Fetch current regime
const treasury = await fetchTreasuryYields();
const assessment = evaluateRegime(treasury);

// Define decision
const decision: DecisionInput = {
  lifecycle: "GROWTH",
  category: "HIRING",
  action: "HIRE",
  context: "Expanding eng team by 3 engineers",
};

// Get verdict
const output = evaluateDecision(assessment, decision);

// Log results
console.log(`Verdict: ${output.verdict}`);
console.log(output.summary);
console.log("\nSensor bullets:");
output.bullets.forEach((bullet) => console.log(`- ${bullet}`));
console.log(`\nGuardrail: ${output.guardrail}`);
console.log(`\nReversal trigger: ${output.reversalTrigger}`);

// Share with team
if (output.verdict === "DANGEROUS") {
  await postToSlack({
    channel: "#planning",
    text: `⚠️ Decision Shield: ${output.summary}`,
    blocks: [
      { type: "section", text: { type: "mrkdwn", text: output.guardrail } },
    ],
  });
}
Decision Shield reflects current conditions only. Re-evaluate decisions weekly or when Signal Ops alerts fire.

Regime Engine

Understand regime classification logic

Signal Ops

Get alerted when regimes change

Time Machine

Test decisions against historical regimes

Briefing Pack

Export verdicts for stakeholder reviews

Build docs developers (and LLMs) love

Get started for freeTalk to us