tradeoff-analysis

$npx mdskill add microsoft/amplifier-bundle-systems-design/tradeoff-analysis

Every design decision answers this:

SKILL.md

.github/skills/tradeoff-analysisView on GitHub ↗
---
name: tradeoff-analysis
description: "Structured tradeoff analysis methodology — the 8-dimension comparison frame, tradeoff matrix template, and common tradeoff patterns. Use when evaluating design alternatives, comparing technology choices, or when the answer is 'it depends.'"
---

# Tradeoff Analysis

## The Central Question

Every design decision answers this:

> **"What does this optimize for, and what does it sacrifice?"**

If you cannot answer this clearly for a design, the design is not yet understood.

## The 8-Dimension Comparison Frame

Evaluate every design alternative against these fixed dimensions. Do not invent new dimensions — force the analysis into this frame so alternatives are comparable.

| Dimension | Key Question | Watch For |
|-----------|-------------|-----------|
| **Latency** | How fast must it respond? | P50 vs P99 distinction; latency budgets per hop |
| **Complexity** | How many concepts must be held in mind? | Operational complexity vs code complexity — they diverge |
| **Reliability** | What is the acceptable failure rate? | Partial degradation vs total failure; blast radius |
| **Cost** | What are the resource costs now and at scale? | Cost curves that are linear now but exponential later |
| **Security** | What is the attack surface? | Authentication, authorization, data exposure, supply chain |
| **Scalability** | What grows with usage, time, and org size? | The thing that scales worst is the bottleneck |
| **Reversibility** | How hard is it to undo this decision? | Data model choices are least reversible; API contracts are hard; implementation details are easy |
| **Organizational fit** | Does this match the team's actual ability? | A design the team cannot operate is a failed design |

## Tradeoff Matrix Template

For comparing N alternatives, fill this matrix:

| Dimension | Option A | Option B | Option C |
|-----------|----------|----------|----------|
| Latency | [rating + note] | [rating + note] | [rating + note] |
| Complexity | ... | ... | ... |
| Reliability | ... | ... | ... |
| Cost | ... | ... | ... |
| Security | ... | ... | ... |
| Scalability | ... | ... | ... |
| Reversibility | ... | ... | ... |
| Org fit | ... | ... | ... |
| **Optimizes for** | [1-line summary] | [1-line summary] | [1-line summary] |
| **Sacrifices** | [1-line summary] | [1-line summary] | [1-line summary] |

Ratings: use qualitative assessments (good/adequate/poor) with a concrete note explaining why. Numeric scores create false precision.

## Common Tradeoff Patterns

These pairs recur across system design. Recognizing the pattern accelerates analysis.

**Consistency vs. Availability** — CAP theorem and its practical implications. Strong consistency requires coordination; eventual consistency allows independent operation. Most systems need consistency for some data and availability for other data — the design question is where to draw the line.

**Simplicity vs. Flexibility** — Simple systems are easy to understand but hard to extend. Flexible systems handle change but are harder to reason about. Prefer simplicity unless you have concrete evidence that flexibility will be needed — not hypothetical future requirements.

**Latency vs. Throughput** — Optimizing for individual request speed often reduces total system throughput (and vice versa). Batching improves throughput but hurts latency. Streaming can sometimes improve both.

**Build vs. Buy** — Building gives control and fit; buying gives speed and maintained infrastructure. The hidden cost of "buy" is operational dependency. The hidden cost of "build" is maintenance burden.

**Centralization vs. Distribution** — Centralized systems are simpler to reason about but create single points of failure and scaling bottlenecks. Distributed systems are resilient but introduce coordination complexity.

**Optimization vs. Observability** — Aggressive optimization (caching, denormalization, precomputation) makes systems faster but harder to debug. Ensure every optimization comes with the monitoring needed to verify it works.

**Safety vs. Speed** — Guardrails (validation, type checking, review processes) slow development but prevent failures. The cost of skipping them is paid later, with interest.

**Present Cost vs. Future Cost** — Technical debt is borrowing from the future. Sometimes that's the right tradeoff — but name it explicitly and track the repayment plan.

## How to Use This Framework

1. **Identify the alternatives.** If you have fewer than 2, you haven't explored enough. If you have more than 5, narrow first.
2. **Fill the matrix.** Force every cell to have a rating and a note. Empty cells mean unexamined risk.
3. **Identify the dominant tradeoff.** Which 1-2 dimensions most differentiate the options? That is where the real decision lies.
4. **State what you are sacrificing.** The recommendation is incomplete without this.
5. **Ask: "What would have to be true for this to be the wrong choice?"** This is the most powerful question in tradeoff analysis. It surfaces hidden assumptions and identifies monitoring signals.

More from microsoft/amplifier-bundle-systems-design

SkillDescription
adversarial-reviewAdversarial review of a system design from 6 critical perspectives -- SRE, security, staff engineer, finance, operator, and developer advocate. Produces a unified risk assessment. Use for INTERACTIVE on-demand reviews during a design conversation (/adversarial-review). For RECIPE-DRIVEN reviews (where prior step context is needed), use the systems-design-critic agent instead.
architecture-primitivesCatalog of reusable architectural primitives — boundaries, contracts, state machines, queues, caches, consistency models, and more. For each: what it is, when it's right, when it's WRONG. Use when selecting patterns for a design or evaluating whether a pattern fits.
design-philosophy-domain-drivenDomain-Driven Design as a lens for system architecture — bounded contexts, aggregates, ubiquitous language, context mapping, domain events, and strategic vs tactical patterns. Use when modeling complex business domains, defining service boundaries, or evaluating whether a system's structure reflects its domain.
design-philosophy-linuxThe Unix/Linux design philosophy as a lens for system design — mechanism vs policy, composability, small tools, text streams, convention over configuration, and the principle of least surprise. Use when evaluating designs for composability, simplicity, or separation of concerns.
design-philosophy-object-orientedObject-oriented design principles as a lens for system architecture — SOLID, composition over inheritance, the actor model, design patterns (and when they're wrong), encapsulation, polymorphism, and responsibility-driven design. Use when evaluating code organization, module boundaries, or object/component relationships.
system-type-azureDomain patterns for Azure cloud architecture — compute selection, managed services, identity (Entra ID), networking, data platform, messaging, deployment, cost management, and operational patterns. Use when designing or evaluating a system deployed on Microsoft Azure.
system-type-cli-toolDomain patterns for CLI tools and developer SDKs — command structure, configuration layering, plugin architecture, distribution, backward compatibility, shell integration, and failure modes. Use when designing or evaluating command-line tools, developer platforms, or SDK libraries.
system-type-data-pipelineDomain patterns for data pipeline architecture — batch processing, stream processing, ETL/ELT, DAG scheduling, data quality, schema evolution, backfill strategies, and failure modes. Use when designing or evaluating data pipelines, ETL systems, or streaming data infrastructure.
system-type-distributedFoundational patterns for distributed systems — consensus, consistency models, replication, partitioning, clock synchronization, distributed transactions, and failure modes. Use when designing or evaluating any system that spans multiple nodes, processes, or failure domains.
system-type-edge-offlineDomain patterns for edge computing and offline-first systems — sync protocols, conflict resolution under partition, local-first architecture, constrained resources, intermittent connectivity, and failure modes. Use when designing or evaluating mobile apps, IoT systems, field-deployed software, or any system that must work without reliable network access.