Strategic coherence

Description

The strategic filter answers a binary question: does this bet belong or not? But passing the filter, one by one, doesn't guarantee that the set of bets that passed forms something coherent. Three bets can each, individually, belong to the strategy, and still not reinforce each other — or, worse, compete for the same user attention without adding anything extra. This lesson goes one step beyond the individual filter: it measures whether the surviving bets leverage each other, or simply share the coincidence of having passed the same test.

Connection to the module. Lessons 3 and 4 worked bet by bet: does this pass? why doesn't this other one? This lesson looks, for the first time, at the complete set of the ones that passed —reviews, sellerTools, recommendations— and asks whether, together, they build something bigger than the sum of their parts, or whether they're three loose initiatives that happened not to collide with avoid.

An everyday analogy: the menu that complements itself, not fifty loose dishes

A good restaurant doesn't have a menu of fifty randomly chosen dishes, each good on its own. It has a menu where the house wine pairs with the main course, the appetizer preps the palate for what's coming, and the dessert closes the meal in the same register it started — a coherent menu, where every choice reinforces the others, even though each dish would also be acceptable served alone. A restaurant with fifty loose dishes, each "good" in isolation but with no relationship to each other, doesn't feel like a designed experience — it feels like a list of possibilities with no criterion behind it.

Strategic coherence is exactly that difference. Each individual bet passing the strategic filter (being "a good dish") isn't enough — the question this lesson teaches you to ask is whether, together, the approved bets build a complete meal around the same two or three dimensions where the strategy decided to bet heavily, or whether they simply share the coincidence of not having been rejected.

Worked example: where the bets that passed the filter concentrate

We extend strategicFilter with a small report, coherenceReport, that counts how many of the approved bets reinforce each winOn dimension. If those bets concentrate on the same few dimensions, there's coherence. If they scatter with no pattern, there isn't.

function riceScore({ reach, impact, confidence, effort }) {
  return (reach * impact * confidence) / effort;
}

function strategicFilter(backlog, strategy) {
  return backlog.map((bet) => {
    const reinforces = bet.servesDimensions.filter((d) => strategy.winOn.includes(d));
    const conflicts = bet.servesDimensions.filter((d) => strategy.avoid.includes(d));
    return {
      feature: bet.feature,
      servesDimensions: bet.servesDimensions,
      reinforces,
      conflicts,
      inStrategy: reinforces.length > 0 && conflicts.length === 0,
      riceScore: Number(riceScore(bet.rice).toFixed(2)),
    };
  });
}

// Pedagogical model: counts how many APPROVED bets reinforce each
// strategy.winOn dimension. Coherence = bets concentrate on the same
// few dimensions, not scattered across unrelated dimensions.
function coherenceReport(filteredResults, strategy) {
  const passed = filteredResults.filter((b) => b.inStrategy);
  const coverage = {};
  strategy.winOn.forEach((d) => { coverage[d] = []; });
  passed.forEach((b) => b.reinforces.forEach((d) => coverage[d].push(b.feature)));
  return coverage;
}

const mercadoStrategy = { winOn: ['curatedDiscovery', 'sellerTrust'], avoid: ['price'] };

const backlog = [
  { feature: 'fasterCheckout', servesDimensions: ['convenience'], rice: { reach: 8000, impact: 2, confidence: 0.8, effort: 2 } },
  { feature: 'recommendations', servesDimensions: ['curatedDiscovery'], rice: { reach: 5000, impact: 1, confidence: 0.5, effort: 3 } },
  { feature: 'sellerTools', servesDimensions: ['sellerTrust'], rice: { reach: 1200, impact: 2, confidence: 0.8, effort: 2 } },
  { feature: 'reviews', servesDimensions: ['sellerTrust'], rice: { reach: 6000, impact: 0.5, confidence: 0.8, effort: 1 } },
  { feature: 'improvedSearch', servesDimensions: ['catalogBreadth'], rice: { reach: 9000, impact: 1, confidence: 0.5, effort: 3 } },
  { feature: 'lowestPriceMatch', servesDimensions: ['price'], rice: { reach: 9500, impact: 3, confidence: 0.8, effort: 3 } },
];

const filtered = strategicFilter(backlog, mercadoStrategy);
const coverage = coherenceReport(filtered, mercadoStrategy);

console.log('=== Coverage: which APPROVED bets reinforce each strategy dimension ===\n');
for (const dim of Object.keys(coverage)) {
  console.log('  ' + dim + ' (' + coverage[dim].length + '): ' + (coverage[dim].join(', ') || '(none)'));
}

const rejected = filtered.filter((b) => !b.inStrategy);
console.log('\n=== The ones that fell out, and which (unrelated) dimension they belong to ===\n');
rejected.forEach((b) => console.log('  ' + b.feature + ' -> ' + b.servesDimensions.join(', ')));

What to expect. Running the file with Node produces exactly this output:

=== Coverage: which APPROVED bets reinforce each strategy dimension ===

  curatedDiscovery (1): recommendations
  sellerTrust (2): sellerTools, reviews

=== The ones that fell out, and which (unrelated) dimension they belong to ===

  fasterCheckout -> convenience
  improvedSearch -> catalogBreadth
  lowestPriceMatch -> price

There's coherence, measured, not just sensed. The three approved bets —recommendations, sellerTools, reviews— concentrate on exactly the two winOn dimensions: one reinforces curatedDiscovery, two reinforce sellerTrust. There's no approved dimension left without a bet, nor any bet falling into a scattered third place — the whole set converges. Compare that to the three rejected bets: convenience, catalogBreadth, and price have no relationship to each other — they're three distinct dimensions, with no connecting thread, each pushing in a different direction. That contrast —convergence versus scattering— is, in a word, the difference between a coherent roadmap and a roadmap that's just a list of features that, individually, don't hurt anyone.

Also notice something that connects directly to module 6: sellerTools and reviews, the two bets reinforcing sellerTrust, don't just satisfy the filter — they each, in their own way, deepen exactly the moats you identified there: the seller network (sellerTools strengthens it directly) and purchase data (reviews generates a trust signal that accumulates with every transaction). Strategic coherence isn't just an aesthetic property of the roadmap — it's often the concrete mechanism by which a set of bets builds a moat that no single loose bet could build on its own.

Deep dive: coherence isn't the same as "many approved bets"

It's tempting to measure coherence by quantity: "we approved three of six bets, that's coherence." It isn't — that's just lesson 3's filter result, applied bet by bet. Real coherence is in the distribution of those approved bets across winOn's dimensions, not in their total count. A hypothetical backlog where three approved bets each reinforce a different dimension of a three-dimension winOn would have the same number of approved bets as Mercado's backlog (three), and yet would be less coherent: each dimension would have exactly one bet behind it, none would be reinforced from more than one angle, and losing any of the three would leave that dimension with no support at all.

Mercado's pattern —one bet on curatedDiscovery, two on sellerTrust— isn't perfectly symmetric, and that asymmetry is real information: it's telling the team, with data, that its strongest bet this quarter is concentrated in seller trust, and that curated discovery, while also reinforced, has relatively less support within this specific backlog. That's exactly the kind of reading a well-built coherenceReport should allow: not just "did it pass or not," but "where are we actually investing, and where do we lack depth?"

Common mistakes

Bets that cannibalize each other instead of reinforcing. What happens: two bets approved by the filter end up competing for the same user attention or the same space instead of adding up — for example, two different features trying to solve the same moment in the purchase journey, in ways that step on each other instead of complementing each other. Why it happens: the strategic filter, as built, verifies that each bet reinforces a winOn dimension — but doesn't check whether two approved bets, when built together, end up getting in each other's way in the real user experience. How to spot it: for any pair of approved bets, ask "if a user uses both in the same session, does the second add something the first didn't give, or does it compete for the same decision?" — if the answer is "it competes," there's cannibalization, not reinforcement. How to fix it: use this lesson's coherenceReport as a starting point, not a final verdict — concentration on the same dimensions is a necessary condition for coherence, but verifying that the bets complement each other in the concrete user experience also requires the same qualitative criterion you used to review real differentiation versus parity in module 4.

Confusing the number of approved bets with real coherence. What happens: the team celebrates that "half the backlog passed the filter" as if the number alone proved a coherent strategy, without looking at which dimensions those approved bets concentrated on. Why it happens: an approval ratio —"3 of 6"— is an easy number to communicate and feels like a success metric, while examining the exact distribution by dimension requires an extra step many teams skip. How to spot it: if your team reports "we approved X bets" without being able to say, from memory, how many reinforce each specific winOn dimension, they're probably confusing quantity with coherence. How to fix it: always report the complete distribution, as in this lesson's table —dimension by dimension, not just the total—, and treat any winOn dimension with no bet behind it as a warning sign, no matter how many bets passed in total.

Building a roadmap where each bet reinforces a different dimension, with none leveraging another. What happens: the team, seeking to "cover all the bases," deliberately spreads its approved bets so each touches a different dimension of the strategy, instead of concentrating effort on deepening the same dimension from several angles. Why it happens: covering every dimension feels more "complete" and more defensible in a presentation than concentrating all effort on just one — nobody can accuse the team of "neglecting" any part of the strategy. How to spot it: check whether any winOn dimension has, systematically, zero or just one bet behind it, quarter after quarter, while the rest split effort evenly — that even distribution rarely builds the concentrated advantage you saw in module 3 (positionFit), which won by a bigger margin than a spread-out investment. How to fix it: remember module 3's pattern: an "even, no-weakness" product won with less margin than one concentrated on its real strength — the same applies to the roadmap. It's fine, and often correct, for most of a quarter's bets to concentrate on a single dimension, if that's the dimension most urgently needing depth.

Exercises

Exercise 1 — Detect cannibalization without running code. Two approved bets, both with servesDimensions: ['curatedDiscovery']: one is "recommendations based on past purchases" and the other is "recommendations based on what similar users buy." Do these two bets reinforce or cannibalize each other? Justify in one sentence.

See solution

It depends on the concrete design, but the cannibalization risk is real: if both end up showing, in practice, almost identical results to the same user at the same moment (because someone's past purchases and similar users' purchases often overlap a lot), the second bet adds little incremental value over the first, even though both "pass" the filter with the same label. They genuinely reinforce each other only if they're designed to cover different cases —for example, the first for recurring buyers with history, the second specifically for new buyers with no history of their own, where the similar-users signal is the only one available. The exercise illustrates strategicFilter's exact limit: approving the same dimension twice doesn't guarantee the two bets complement each other; the concrete design needs review.

Exercise 2 — Calculate the coverage of a hypothetical backlog. An alternative backlog has four approved bets: two with servesDimensions: ['curatedDiscovery'], one with ['sellerTrust'], and one with ['curatedDiscovery', 'sellerTrust'] (reinforcing both at once). Calculate each dimension's coverage using coherenceReport's logic.

See solution

curatedDiscovery would have coverage 3: the two bets that only reinforce that dimension, plus the fourth bet that reinforces both (counted in both). sellerTrust would have coverage 2: the bet that only reinforces sellerTrust, plus that same fourth bet. The fourth bet —the one reinforcing both dimensions at once— is, in a sense, the most valuable from a coherence perspective: it doesn't just belong to the strategy, it connects the two winning dimensions in a single initiative, instead of treating them as separate efforts.

Exercise 3 — Present the coverage to a stakeholder asking for "more variety." A stakeholder, seeing that two of the three approved bets reinforce sellerTrust and only one reinforces curatedDiscovery, asks for "more variety" and suggests adding a bet serving catalogBreadth to "balance the roadmap." Write, in a paragraph, how you'd respond using this lesson's argument.

See solution

A sample answer: "I understand the instinct to look for variety, but 'balanced' isn't a strategic roadmap's goal — coherent is, and they're not the same thing. Our three bets this quarter concentrate, on purpose, on the two dimensions we chose to win on: curated discovery and seller trust. Adding a bet on catalogBreadth wouldn't balance it toward something better — it would scatter it toward a third dimension we didn't choose to compete on, exactly the same pattern we saw with improvedSearch in lesson 4, which didn't pass the filter for that same reason. We'd rather have two bets deepening sellerTrust from different angles —seller tools and buyer reviews— than three bets scattered across three unrelated dimensions. The variety that adds up is the kind that reinforces the same game from several angles, not the kind that adds new games."

Summary and next step

This lesson went beyond the bet-by-bet filter and measured the complete set: coherenceReport showed that Mercado's three approved backlog bets concentrate exactly on the two winOn dimensions —one on curatedDiscovery, two on sellerTrust—, while the three rejected ones scatter with no relationship to each other across convenience, catalogBreadth, and price. That concentration, not the number of approved bets, is what separates a coherent roadmap from a simple list of individually acceptable features.

Before moving on you should be able to: distinguish "many bets passed the filter" from "the bets that passed reinforce each other," and recognize when a demand for "more variety" is actually asking for scattering, not coherence.

Lesson 6 takes the other side of the same table —the three bets that didn't pass the filter— and teaches you to communicate that NO with an explicit reason, instead of leaving it as an awkward silence in the next roadmap meeting.

Resources

• Roger Martin, "Decoding the Strategy Choice Cascade" — rogermartin.medium.com/decoding-the-strategy-choice-cascade-475d40555eb1. Martin insists that the cascade's five choices must be mutually reinforcing —each choice makes the others stronger—, not just individually defensible; the same coherence criterion from this lesson, applied to the complete strategy. In English.
• Marty Cagan (Silicon Valley Product Group), "Product Strategy" — svpg.com/product-strategy-overview. Cagan describes a good product strategy as a set of bets that accumulate toward the same outcome, not a collection of mutually independent improvements. In English.
• Melissa Perri, Escaping the Build Trap — oreilly.com/library/view/escaping-the-build/9781491973767. Perri warns against roadmaps that look productive by their volume of shipped work, with nobody checking whether that work accumulates toward a real competitive advantage or scatters without consolidating anything. In English.