README.md

metadata

title: DecisionForge | Strategic Decision Intelligence
emoji: 🧭
colorFrom: indigo
colorTo: blue
sdk: static
app_file: index.html
pinned: false
license: mit
short_description: Strategic decision analysis and scenario testing.
tags:
  - decision-support
  - multi-criteria-decision-analysis
  - strategic-planning
  - scenario-analysis
  - operations-research
  - sensitivity-analysis

DecisionForge | Strategic Decision Intelligence

Project #78 in the Hugdrigo portfolio | Free, responsive, self-contained Hugging Face Static Space.

Short description: Strategic decision analysis and scenario testing.

DecisionForge is a professional, transparent multi-criteria decision analysis (MCDA) application. It compares strategic alternatives, reveals weighted score contributions, examines priority changes through one-way sensitivity sweeps, and stress-tests uncertain assumptions in a seeded Monte Carlo simulation. It runs completely in the browser with no backend, no package installation, no external APIs, no accounts, no paid services, no telemetry, and no AI-model inference.

Important: This is explainable decision-support software, not a trained prediction model or a source of verified financial, safety, strategic, or legal outcomes. The supplied strategic options and all their metrics are fictional demonstration data.

1. Capabilities

Area	Implemented functionality
Decision dashboard	Live ranking, leading option, leader margin, simulated win frequency, criterion contribution bars, Pareto-dominance flags
Editable options	Add, rename, change data values, or delete strategic alternatives
Editable criteria	Add, edit or delete factors; define descriptive units, preference orientation, low/high reference anchors, and raw priority weights
Scenario laboratory	Instant reweighting, four demonstration presets, dynamically normalized priorities
Sensitivity	21-step one-way sweep of each criterion's normalized weight from 0% to 100% with a multi-option line chart
Uncertainty lab	1,200 seeded perturbation draws, win frequencies with fractional tie treatment, p10 / median / p90 weighted-score ranges
Portable data	Browser-local persistence, workspace JSON export/import with schema validation, example JSON, ranked CSV export
Accessibility	Semantic navigation, accessible input names, visible focus styles, keyboard interaction, responsive layouts, browser print summary
Security and privacy	Self-contained source, no third-party code, no network requests, escaped user-authored text, explicit confirmation before destructive actions

Workspace bounds: 2–12 alternatives, 2–8 criteria, 1–60 characters for an option name, 1–55 characters for a criterion name, finite numeric values, max 300 KB imported JSON, uncertainty setting 0–25% of each criterion's reference span. No time-based historical data or external datasets are required.

2. Publish as a free Hugging Face Space

1. Sign in to Hugging Face at https://huggingface.co/ and open https://huggingface.co/new-space.
2. Owner: Hugdrigo
3. Space name: decisionforge-strategic-intelligence
4. Short description: Strategic decision analysis and scenario testing.
5. License: MIT.
6. SDK / Space type: Static.
7. Visibility: Public.
8. Create the Space and add exactly the following three files to the root of the repository:
   • README.md
   • index.html
   • LICENSE
9. Commit the files and open the Space's App tab. The app requires no dependencies, tokens, payment details, environment variables, GPU, backend, or build step.

The README must begin directly with the YAML frontmatter at its first line. Its essential settings are:

sdk: static
app_file: index.html
license: mit

Official documentation: https://huggingface.co/docs/hub/spaces-sdks-static

Run locally

Open index.html in a modern browser. It is fully standalone. Depending on browser security settings, local-file origins may restrict persistent storage or some downloads; standard HTTP hosting and the Hugging Face Static runtime do not have that local-file-origin limitation. The application remains usable even when local storage is blocked (with temporary in-memory edits).

3. Using the studio

1. Overview: Read the preferred option and scores. The initial results use fictional business investment alternatives.
2. Decision matrix: Enter raw measurements for each alternative, such as revenue potential, months to launch, or operational risk.
3. Edit criteria: Set the units, high/low anchors, whether higher or lower values are desirable, and each criterion's weight. Choose independent factors to avoid double counting.
4. Scenarios: Try changing priority weights. Presets target the five example criteria. With custom criteria, tune their weights individually.
5. Sensitivity: Select one criterion; follow how each option's score and rank changes as its normalized weight grows from 0 to 100%.
6. Uncertainty: Select an illustrative perturbation size and examine 1,200 reproducible simulated rankings and score intervals.
7. Export: Save the editable workspace as JSON before resetting or clearing browser data. Export a ranked CSV for offline analysis, or use Report to print an executive summary.
8. Import: Import a previously exported decisionforge-workspace.json. Invalid files are rejected and existing data remain unchanged; valid imports require explicit confirmation before overwriting local changes.

Edits save automatically to the browser's localStorage, when permitted. JSON export is the portable backup mechanism. No cloud synchronization is provided or claimed.

4. Reference data (fictional)

The starter workspace contains four made-up project alternatives:

• SaaS Expansion
• Regional Partnership
• Process Automation
• New Market Entry

Five illustrative, user-editable criteria:

Criterion	Preference	Fixed low anchor	Fixed high anchor	Baseline raw weight
Strategic fit (pts)	Higher is better	0	100	25
Annual net value ($k)	Higher is better	0	1000	30
Time to launch (months)	Lower is better	1	24	15
Delivery risk (pts)	Lower is better	0	100	20
Sustainability (pts)	Higher is better	0	100	10

All default values are synthetic and are not measured company performance. Anchors are explicit references selected by the analyst and do not auto-adjust when the analyst adds, edits, or removes options. This avoids the often-surprising rank perturbations caused solely by changing a relative min-max normalization population.

5. Numerical methodology

5.1 Criterion scoring

For criterion j, with low anchor L_j, high anchor H_j, and raw performance x_ij for option i:

t = clamp((x_ij - L_j) / (H_j - L_j), 0, 1)
criterion_utility_ij = 100 * t             if higher is better
criterion_utility_ij = 100 * (1 - t)       if lower is better

H_j > L_j is mandatory. Values outside the selected anchor range are capped, so they do not increase scores above 100 or below 0. The analyst must decide whether each anchor range is realistic and meaningful.

5.2 Criterion weights and option utility

All raw criterion weights are nonnegative integers between 0 and 100; at least one must be positive.

normalized_weight_j = raw_weight_j / sum(raw_weight_all_criteria)
weighted_score_i   = sum(normalized_weight_j * criterion_utility_ij)

Every option's weighted score lies between 0 and 100. Equal results are ordered alphabetically for display. Small scoring gaps should not be interpreted as established differences in real outcomes.

5.3 Pareto-dominance flag

Option A dominates option B when all A's normalized criterion scores are at least B's and A is strictly superior in at least one criterion. A Pareto-dominated alternative cannot maximize a strictly positive-weight sum when its dominator's superior criterion has positive weight. The badge is informational and uses all criteria, including those currently weighted zero.

5.4 One-way sensitivity analysis

For a chosen criterion k, sweep its normalized importance p through [0, 0.05, 0.10, ..., 1].

• Assign criterion k the exact weight p.
• Allocate remaining weight (1-p) proportionally across the other criteria, using their existing raw weights.
• If all other criteria have raw weight zero, split the remaining weight equally across those other criteria.
• Recalculate the scores across all alternatives at all 21 settings.

The chart is not a probabilistic forecast. It reveals how ranks depend on the stated preference weights.

5.5 Illustrative uncertainty stress test

Each raw performance input is independently perturbed 1,200 times using a deterministic pseudorandom generator seeded from the exact current model state. The scenario's uncertainty slider u ranges from 0 to 0.25:

U1, U2 ~ Uniform(0, 1)      # two pseudorandom draws
triangular_shift = (U1 + U2 - 1) * u * (H_j - L_j)
shocked_value = clamp(x_ij + triangular_shift, L_j, H_j)
shocked_utility = weighted_score(shocked_values)

This is a symmetric triangular perturbation with maximum absolute deviation of u * (H_j - L_j). For each simulation:

• Each option's weighted score is recorded.
• Each winning option receives one win. Any exact tie splits that win evenly across the tied leaders.
• Win rate = win credits ÷ 1,200.
• The 10th, 50th and 90th percentiles use linear interpolation between sorted samples.

For unchanged inputs, the same sample sequence is reused; users can reproduce exact results. Independence, triangular error shape, identical relative uncertainty across criteria, and the choice of u are modeling assumptions rather than empirically estimated uncertainty distributions. Simulated win frequencies are not the objective probability that a business decision will succeed.

6. Data schema and export limits

JSON follows this structure:

{
  "version": 1,
  "criteria": [
    {"id": "fit", "name": "Strategic fit", "unit": "pts", "direction": "higher", "low": 0, "high": 100, "weight": 25}
  ],
  "options": [
    {"id": "saas", "name": "SaaS Expansion", "values": {"fit": 92}}
  ],
  "uncertainty": 12
}

This snippet shows the field contract but is not a valid import by itself because a workspace requires at least two complete criteria and two complete options. Use Example JSON to obtain a ready-to-import valid workspace.

The ranked CSV contains rank, option name, weighted score, illustrative simulated win share, each raw input and each normalized criterion score. A BOM is not prepended. CSV text cells are RFC-style quoted with embedded quotation marks doubled. Imported workspaces are validated before replacing active data.

7. Scientific and operating limitations

• Weighted additive models assume preferences can reasonably be represented by a sum of normalized utilities. Criteria may not be independent and can encode subjective judgments or duplicate each other.
• Fixed linear anchors and clipping are useful for interpretable trade-offs, but the real value of some metrics is nonlinear, discontinuous, or contextual.
• Sample strategic options are hypothetical, not actual investment or operating recommendations. No market data or user-specific records are retrieved.
• Simulation results are sensitive to the analyst's chosen perturbation range and the independence/distribution assumptions. There is no model training, statistical fitting, predictive AI, live API, or verified probability calibration.
• This tool does not solve constraints, optimize integer projects, assign resources, or perform a rigorous causal impact evaluation.
• Browser-local data can be lost when users clear site storage or switch browsers/devices. Export JSON to retain work; the app does not upload or sync it.
• Printing uses standard browser print-to-PDF if the user chooses it. No server-generated reports or backend are included.

8. QA and reproducibility

Local static validation, 15,504 numerical property checks, and headless Chromium interaction checks were run before packaging. Tests covered:

• JavaScript syntax parsing and interactive rendering.
• Validity of default normalizations, orientation handling and clipping.
• Weighted score bounds and total normalized weight of 100%.
• Monte Carlo seeded reproducibility and 100% allocation of win credits.
• Sensitivity charts, all four initial alternatives, scenario presets and changed-weight calculations.
• Editing and persistence of matrix values; creation of alternative and criterion; weight guard against zeroing every criterion.
• JSON, CSV, and example dataset exports; valid JSON import, invalid JSON rejection, alternative removal, and criterion editing.
• Empty/invalid schema rejection, zero-uncertainty tie handling, malicious HTML text escaping, and non-destructive reset confirmation.
• Desktop viewport and 390-pixel mobile layout with internally scrollable matrix and no viewport-level horizontal overflow.
• No browser uncaught JavaScript errors on tested interactions.

Scope of QA: Local browser checks are not equivalent to a deployed Space's production smoke test. After publication, open the Hugging Face App page and independently confirm that it renders, edits, exports, imports, and persists local state under the hosted origin.

9. Project structure and licensing

DecisionForge_Project_78/
├── README.md      # Hugging Face frontmatter, usage, methodology
├── index.html     # Entire application: HTML + CSS + JavaScript
└── LICENSE        # MIT License (copyright Hugdrigo, 2026)

Hugging Face Static Space documentation: https://huggingface.co/docs/hub/spaces-sdks-static

Author: Hugdrigo | Project: #78 | License: MIT | Dependencies: None.