API integration prioritization framework

Purpose

Turn a messy list of requested, proposed, or competitor-driven integrations into a defensible, weighted ranking — so product teams build the integrations that compound platform value instead of the ones that shout loudest. Produces a scored matrix, a sequenced roadmap, and a clear "not now" list.

When to Use

Invoke this skill when the user asks to:

• Decide which integrations or partner APIs to build next quarter
• Rank a backlog of requested third-party integrations
• Sequence an integration roadmap across multiple releases
• Justify or defend integration investment to leadership or a partner team
• Compare a high-demand integration against a high-strategic-value one
• Build a repeatable scoring rubric the team can reuse for future requests

Inputs Required

Before starting, collect:

• Candidate integrations: The list of integrations being evaluated (5–30 typical), with a one-line description each
• Platform context: What the platform does, who its users are, and the business model (SaaS, marketplace, dev platform, etc.)
• Strategic priorities: Top 2–3 company/product goals this year (e.g., enterprise expansion, reducing churn, new market entry)
• Developer/customer demand signals: Any available data — support tickets, sales-blocked deals, community requests, usage of existing integrations
• Engineering capacity: Rough team size or available integration-build bandwidth per quarter
• Known constraints: Partner API maturity, contractual blockers, security/compliance requirements, deprecation risks

If demand data is unavailable, score demand from qualitative signals and flag the assumption. If weights aren't specified, apply the default weighting in Step 1 and state it.

Instructions

Step 1: Establish the Weighted Criteria Model

Score each integration on six criteria, each rated 1–5. Apply default weights unless the user specifies their own:

Note: Cost and Risk are inverse — a 5 means "low cost"/"low risk." State the active weights explicitly before scoring.

Step 2: Score Each Candidate

For every integration, assign a 1–5 score per criterion with a one-line justification. Anchor scores to concrete signals:

• Demand 5: Repeatedly blocking deals or top community request; Demand 1: Speculative, no signal
• Cost 5: Mature partner API, well-documented, days of work; Cost 1: Immature/undocumented API, ongoing maintenance, weeks of work
• Strategic Value 5: Directly unlocks a stated top-3 priority; Strategic Value 1: Tangential to current goals

Avoid clustering everything at 3 — force differentiation.

Step 3: Calculate Weighted Scores and Rank

For each integration, compute the weighted total: sum of (criterion score × weight). Express on a 0–5 scale. Rank from highest to lowest. Present results in a scoring matrix table with every criterion score, the weighted total, and the rank.

Step 4: Apply the Quadrant Overlay

Plot each integration on two axes — Value (Strategic + Demand + Revenue) vs. Effort (Cost + Risk) — and label its quadrant:

• Quick Wins (high value, low effort): Build first — flag explicitly
• Strategic Bets (high value, high effort): Sequence deliberately, often phased
• Fill-Ins (low value, low effort): Batch when capacity allows
• Money Pits (low value, high effort): Defer or decline

Step 5: Build the Sequenced Roadmap

Translate the ranking and quadrants into a release sequence matched to the stated engineering capacity:

• Group into Now / Next / Later (or Q1/Q2/Q3 if a cadence is given)
• Front-load Quick Wins for early momentum, then Strategic Bets
• Note any dependency chains (Integration A enables B)
• Show roughly how the sequence fits the available bandwidth — don't overload a quarter

Step 6: Produce the Deferral List with Rationale

List every integration marked "not now" with a one-sentence reason and a revisit trigger (e.g., "Revisit if it blocks 3+ enterprise deals" or "Revisit when partner API exits beta"). This is what protects the roadmap from re-litigation.

Output Format

• Structure: Active weighting statement → scoring matrix table → quadrant overlay → sequenced roadmap → deferral list
• Length: 800–1,200 words plus tables
• Format: Tables for the scoring matrix and quadrant; structured lists for roadmap and deferrals; brief prose for rationale
• Sections: Criteria & Weights → Scoring Matrix → Quadrant Overlay → Sequenced Roadmap → Deferral List → Top Recommendation
• Tone: Product leader — decisive, data-anchored, willing to deprioritize loud-but-low-value requests

Quality Checklist

Before delivering output, verify:

• [ ] Every candidate integration appears in the scoring matrix with all six criterion scores
• [ ] Active weights are stated explicitly and sum to 100%
• [ ] Cost and Risk are scored as inverse (low cost/low risk = high score) consistently
• [ ] Weighted totals are calculated correctly and the ranking matches them
• [ ] Each integration is assigned exactly one quadrant
• [ ] The roadmap respects the stated engineering capacity — no quarter is silently overloaded
• [ ] Every deferred integration has a revisit trigger, not just a rejection

Notes

• The most common failure mode is over-indexing on demand — the loudest request is rarely the highest strategic value. The weighting exists to counter this.
• If two integrations tie on weighted score, break the tie by Ecosystem Leverage — integrations that enable future integrations compound.
• Recommend re-running this framework quarterly; weights should shift as strategic priorities change, and last quarter's "Later" items may have new demand signals.
• When implementation cost is uncertain, score conservatively (lower) — underestimated integration cost is the most frequent roadmap-buster.

How to use this skill

This file is a Claude Code skill in Anthropic's standard format — markdown with YAML frontmatter at the top.

Installing in Claude Code:

• ~/.claude/skills/<folder-name>/SKILL.md — auto-loads in every session anywhere on your machine (recommended for skills you'll use across multiple projects)
• <your-project>/.claude/skills/<folder-name>/SKILL.md — auto-loads only when working in that project (recommended for project-specific skills)

Restart Claude Code or open a new session to register.

Using in Claude.ai, ChatGPT, Gemini, or other AI tools:

1. Drag this file into a new chat, or copy and paste its contents
2. Send your task or request as your next message — the AI will apply the skill where it fits

For Claude Code skill details: https://docs.anthropic.com/en/docs/claude-code/skills