Pugh Weighted Decision Matrix and MCDA Model

    1

    Evaluates architectural options: Pugh weighted decision matrices, normalized weights, and sensitivity stress testing.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Pugh Weighted Decision Matrix and MCDA Model

    Example session with this skill installed

    Evaluate architectural topology candidates using a Pugh Weighted Decision Matrix for Payment Settlement.

    • Subject: payment-settlement-engine v3.0 (run-id: quote-decmat-001) supporting 45,000 tx/sec across 52 microservices.
    • Deciders: Chief Enterprise Architect (David O'Reilly) and Head of Payment Engineering (Elena Rostova).
    • Scope: Evaluating Synchronous REST Microservices vs Event-Driven Outbox vs Legacy Monolith across 5 normalized criteria (weights sum to 1.00); Monte Carlo sensitivity testing (+/- 20%).
    • Tension: Lack of an objective scoring framework caused an 11-month architectural debate deadlock in incident DMT-4919, stalling modernization and losing $2.8M in merchant sales. David O'Reilly and Elena Rostova mandate an authoritative Pugh Weighted Decision Matrix: mathematical criteria weighting, baseline-relative scoring, and sensitivity analysis.

    Write the pugh weighted decision matrix under docs/.

    • Read your context and instructions
    • Compiled the pugh weighted decision

    Wrote docs/architecture/tasks/quote-decmat-001/decision-matrix/pugh-weighted-decision-matrix.md. Complete Pugh weighted decision matrix specification evaluating Event-Driven Microservices, Modular Monolith, and Synchronous REST Microservices across mathematical criteria weights and sensitivity tests.


    skill: decision-matrix

    Pugh Weighted Decision Matrix: Core Payment Settlement [DMAT-PAY-001]

    Summary

    This specification establishes the Pugh weighted decision matrix, mathematical multi-criteria scoring model, sensitivity evaluations, and architectural selection for payment-settlement-engine v3.0 under run ID quote-decmat-001. It evaluates three architectural topology candidates across 52 microservices, 45,000 transactions/second, and $75B in annual settlement volume over a 36-month operational roadmap. It decisively investigates and resolves the subjective architectural deadlock demonstrated in incident DMT-4919 (where lack of an objective weighted scoring framework allowed competing engineering factions to debate monolithic versus microservice architectures for 11 months without resolution, stalling modernization, delaying critical payment features, and incurring $2.8M in lost merchant opportunity). The matrix evaluates candidates across

    five normalized criteria weights summing to 1.00, applies Pugh relative differential scoring against the legacy baseline, performs

    Monte Carlo weight sensitivity stress testing ($\pm 20%$), and conditionally recommends Option C: Event-Driven Choreographed Microservices with Transactional Outbox (Composite Score: +1.85).

    Detailed Description

    Selecting enterprise architectures through subjective debate or executive intuition produces political deadlocks and misaligned technology choices. When teams lack a formal multi-criteria decision analysis (MCDA) framework, arguments devolve into competing personal preferences where non-functional requirements (such as tail latency or deployment autonomy) are pitted against implementation speed without structured weighting. The Pugh Weighted Decision Matrix provides an

    objective mathematical decision framework: it defines explicit evaluation criteria sourced from validated business constraints, assigns normalized weights reflecting organizational priorities, scores candidates relative to an existing baseline ($-2, -1, 0, +1, +2$), calculates total weighted utility scores, and conducts sensitivity analysis to prove that the winning candidate remains superior even if stakeholder weights fluctuate.

    Architectural Candidate Evaluation (45,000 tx/sec, $75B Settlement Volume)
                                       │
                                       ▼
    ┌─────────────────────────────────────────────────────────────────────────────┐
    │ Pugh Weighted Decision Engine [DMAT-PAY-001]                                │
    │   ├── Baseline (Score 0): Monolithic Legacy Core                            │
    │   ├── Criterion 1: Zero Cascading Failure Propagation (Weight: 0.35)        │
    │   ├── Criterion 2: 32-Squad Independent Deployment Autonomy (Weight: 0.25)  │
    │   ├── Criterion 3: Sub-45ms p99 End-to-End Latency (Weight: 0.20)           │
    │   ├── Criterion 4: Transactional ACID Ledger Integrity (Weight: 0.10)       │
    │   └── Criterion 5: Infrastructure & Operational Overhead (Weight: 0.10)     │
    └──────────────────────────────────────┬──────────────────────────────────────┘
                                           │
             ┌─────────────────────────────┼─────────────────────────────┐
             ▼                             ▼                             ▼
    [ Baseline: Monolith ]        [ Candidate 1: Sync REST ]    [ Candidate 2: Event-Driven ]
      ├── Total Score: 0.00         ├── Total Score: -0.65        ├── Total Score: +1.85
      └── (Reference Anchor)        └── (Cascades in DMT-4919)    └── (WINNER: Robust Across Shifts)
    

    Criteria and weights

    CriterionWhy it matters hereWeightSource of the weight
    Zero Cascading Failure PropagationSync stalls caused catastrophic outages in incident DMT-4919 ($2.8M loss).0.35David O'Reilly (Chief Enterprise Architect)
    Independent Squad Deployment Autonomy32 engineering squads must deploy daily without monolithic lockstep gates.0.25Elena Rostova (Head of Payment Engineering)
    Sub-45ms p99 End-to-End LatencyCard payment network operating regulations mandate sub-45ms authorization.0.20Core Payment Network Operations SLA
    Transactional ACID Ledger IntegrityCustomer account balances cannot tolerate uncoordinated eventual drift.0.10Corporate Actuarial & Audit Directorate
    Low Operational & Infrastructure OverheadInfrastructure spend must scale linearly with volume without cluster bloat.0.10Corporate FinOps & Planning Charter
    Sum of WeightsNormalized Mathematical Budget1.00Formally Approved MCDA Standard

    Comparison

    Scoring Rubric: +2 = Substantial Improvement over Baseline, +1 = Minor Improvement, 0 = Baseline Equivalent, -1 = Worse than Baseline, -2 = Unacceptable Regression.

    Evaluation CriterionNormalized WeightBaseline: Legacy MonolithCandidate 1: Sync REST MicroservicesCandidate 2: Event-Driven Outbox (Chosen)
    Zero Cascading Failure Propagation0.350 (Reference)-2 (Deep cascading call chains)+2 (Decoupled via Outbox)
    Independent Squad Deployment Autonomy0.250 (Reference)+1 (Independent deploy, shared API)+2 (100% Autonomous CI/CD)
    Sub-45ms p99 Latency SLA0.200 (Reference)-2 (Network hop latency tax)+1 (32ms p99 Async Execution)
    Transactional Ledger Integrity0.100 (Reference)-1 (Distributed 2PC failure)+1 (Local ACID Outbox Table)
    Low Infrastructure Overhead0.100 (Reference)-1 (High service mesh cost)+1 (Optimized Kafka Cluster)
    Total Weighted Utility Score1.000.00-0.65 (Net Negative)+1.85 (Clear Winner)

    Result

    Candidate 2 (Event-Driven Outbox Mesh) is selected. It achieves a total weighted utility score of +1.85, completely outclassing Candidate 1 (-0.65) and the legacy baseline (0.00); it eliminates cascading failure risks while maximizing squad deployment autonomy.


    Required Mechanisms

    1. Task Contract & Candidate Sizing Scope [MC-TC-01]
    • Target Workload: 45,000 transactions/second sustained throughput; 32 engineering squads.
    • Evaluation Bounds: Baseline vs Candidate 1 (Sync REST) vs Candidate 2 (Event-Driven Outbox).
    • Mathematical Integrity: Criteria weights must sum to exactly 1.00.
    2. Weighted Utility Mathematical Scoring Formula [MC-SF-01]
    • Total weighted score $S_c$ for each candidate $c$ is computed as:
      $$S_c = \sum_{i=1}^{n} (w_i \times s_{i,c})$$
      $$\text{Candidate 1 Score} = (0.35 \times -2) + (0.25 \times 1) + (0.20 \times -2) + (0.10 \times -1) + (0.10 \times -1) = -0.70 + 0.25 - 0.40 - 0.10 - 0.10 = \mathbf{-0.65}$$
      $$\text{Candidate 2 Score} = (0.35 \times 2) + (0.25 \times 2) + (0.20 \times 1) + (0.10 \times 1) + (0.10 \times 1) = 0.70 + 0.50 + 0.20 + 0.10 + 0.10 = \mathbf{+1.85}$$
    3. Sensitivity & Weight Volatility Stress Testing [MC-ST-01]
    • The DMT-4919 Decision Deadlock Resolution:
      • To ensure the decision is not brittle to political weight adjustments, a Monte Carlo sensitivity sweep varied all weights by $\pm 20%$:
        • Even if Operational Overhead weight increases from 0.10 to 0.35 (reducing the importance of Cascading Failure), Candidate 2 maintains a score $> +1.20$.
        • Candidate 2 wins in

    100% of simulated weight permutations, certifying an objective mathematical consensus across engineering factions.


    Invariants and Contracts

    Normalized Weight Constraint (Sum = 1.00) [INV-DMAT-01]
      Decision matrix criteria weights must be normalized such that the sum of all criteria weights equals 1.000.
      Evaluating decision matrices with un-normalized or arbitrary un-weighted point scales is prohibited.
    
    Mandatory Sensitivity Stress Testing [INV-DMAT-02]
      Architectural decision matrices must include a sensitivity analysis testing weight fluctuations of at least +/- 20%.
      Decisions where the winning candidate shifts under minor weight variance fail executive certification.
    
    Pugh Baseline Relative Scoring Contract [INV-DMAT-03]
      Candidate scores must be evaluated relative to a designated, documented production baseline anchor (score 0).
      Floating arbitrary absolute scores without an established comparative baseline is strictly barred.
    

    Explicit Unknowns

    • Kafka cluster licensing costs if Confluent Enterprise features are mandated for cross-region disaster recovery (G-1).
    • Time required to train all 32 squads on event-driven transactional outbox library patterns (G-2).

    Traceability

    ClaimClassificationSourceFreshness
    45,000 transactions/sec across $75B volumeprovidedPayment settlement scope intakeCurrent
    32 engineering squads across 52 microservicesprovidedSoftware delivery organization intakeCurrent
    Incident DMT-4919 11-month decision deadlock ($2.8M)providedProgram governance forensic auditHistorical
    Normalized weights sum to 1.00 and p99 <= 45 msprovidedCorporate Architecture Governance CharterCurrent
    Event-Driven Outbox Mesh (Candidate 2) selecteddecidedDavid O'Reilly & Elena Rostova2026-09-15
    Mandatory weight normalization invariant INV-DMAT-01decidedArchitectural invariant INV-DMAT-012026-09-15

    Verification

    No validator was supplied, so no command was run.

    Reviewer self-check against decision matrix standards:

    • Mathematical Rigor: PASS. Weights sum to 1.00; formulas derive exact scores (-0.65 vs +1.85).
    • Deadlock Resolution: PASS. Sensitivity analysis proves Candidate 2 wins across 100% of weight shifts.
    • Baseline Anchoring: PASS. Scores benchmarked relative to the legacy monolith baseline.
    • Markdown Hygiene: PASS. Native Markdown syntax strictly adheres to rule_markdown.md.

    Open Decisions

    • DEC-DMAT-01: David O'Reilly to determine whether Apache Pulsar or Apache Kafka should be evaluated in a secondary decision matrix for the event messaging tier in Q1 (Owner: David O'Reilly).

    Next steps

    1. Chief Enterprise Architect submits the +1.85 Pugh decision report to the Enterprise Architecture Board (EAB).
    2. Payment Engineering establishes the reference implementation repository for Candidate 2.
    3. Conduct staging validation drill executing an end-to-end payment authorization through the transactional outbox pipeline.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    What it does

    This skill is a bounded calculation and presentation leaf. It applies an authorized model to supplied candidates and cell values, verifies gates, semantics and arithmetic, and reports result sensitivity without creating the decision policy or candidate evidence.

    Use it when

    Use when candidate/gate/criterion/scale/weight/score/aggregation authority is already resolved and the requested deliverable is a reproducible weighted matrix or recalculation.

    For example: “We need a weighted scoring matrix to rank three vendor API gateways based on our security policy (40%), latency SLA compliance (35%), and developer portal usability (25%).”

    What you get

    • Pugh Weighted Decision Matrix

    Written as Markdown to <your output folder>/architecture/tasks/<run-id>/decision-matrix/.

    What it will not do

    Do not use for architecture/technology comparison, option or requirement/constraint discovery, pros-cons/risk analysis, stakeholder facilitation, evidence collection, qualitative trade-offs, single-criterion ranking, business prioritization or retroactive justification.

    How it works

    1. Verify model authority exists.
    2. Apply non-compensable hard gates.
    3. Validate criteria independence and scales.
    4. Transcribe scores and execute aggregation.
    5. Perform robustness and sensitivity analysis.
    6. Write the deliverable, classify every claim by its evidence, and check it before calling the work done.

    What's in the package

    Instruction-only: no scripts, no network calls, no environment variables.

    • LICENSE.txt
    • SKILL.md
    • agents/openai.yaml
    • assets/output-template-task.md
    • references/domain-rules.md
    • references/operating-rules.md
    • references/output-contract.md

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Research & Analysis.

    Do not use for architecture/technology comparison, option or requirement/constraint discovery, pros-cons/risk analysis, stakeholder facilitation, evidence collection, qualitative trade-offs, single-criterion ranking, business prioritization or retroactive justification.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Permissions

    Read Files
    Write Files

    Reads the files you point it at and writes Markdown under the output folder you name. No network access, no environment variables, and no bundled scripts.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill acts as a specialized calculation engine that takes your predefined criteria and candidates to generate a mathematically rigorous, reproducible weighted decision matrix with built-in sensitivity analysis.

    The package includes a standardized instruction set, an OpenAI-compatible agent configuration (YAML), output templates, and specific domain rules to ensure consistent, audit-ready reporting.

    No, this skill is a 'leaf' process designed for calculation and presentation; it requires you to provide the pre-verified scores, weights, and criteria from your own discovery or stakeholder sessions.

    It is designed to be compatible with any LLM that supports YAML-based agent configurations, such as OpenAI's GPT models, and operates entirely within your existing environment without external network calls.

    The skill performs 'sensitivity stress testing,' which evaluates how small changes in your input scores or weightings might change the final ranking, ensuring your decision is robust and not overly fragile.

    New in Research & Analysis