Module 8: Project Define Mercados Strategy

Where to play

Next →

Description

The one-pager's second layer answers the cascade's first real choice: who is Mercado for, and who wins on that ground? This lesson doesn't redefine the segment or the positioning —you already did that in module 3, with six complete lessons dedicated to that question—, it runs positionFit on the exact case you already built there: the chosen segment (explorers), the explicitly excluded segment (exactSkuShoppers), and the two real alternatives (genericMegastore, localShop). The result fills the one-pager's whereToPlay layer.

Connection to the module. This lesson reuses positionFit verbatim from module 3, with no change to the formula or the data. The only new thing is where the result lives — it's no longer an isolated exercise from that module, it's the second fixed piece of a document that, by the end of this module, is going to chain four different models into a single run.

An everyday analogy: the ground before the game plan

No soccer coach designs the match tactics before knowing which field they're going to play on — whether the ground is natural grass soaked by rain or dry synthetic turf, whether it's narrow or wide, completely changes which strategy makes sense. "Where do we play" isn't a rhetorical question or a formality before the "interesting" part — it's the data point that determines which tactics are even viable. A team that practiced a wide-field game plan all week and shows up to a narrow field can't simply run the same plan harder: the terrain changed the rules of what game it can play well.

This one-pager layer is exactly that ground inspection, done with numbers instead of eyesight: positionFit confirms, with verifiable data, on exactly which ground Mercado wins —and on which, in all honesty, it loses—, before any "how to win" decision (the next lesson) makes sense.

Worked example: the chosen segment wins, the excluded one loses

We run positionFit twice on the same module 3 data: first against the segment Mercado chose to serve (explorers), then against the segment it explicitly decided not to pursue (exactSkuShoppers), both against the same two alternatives.

function positionFit(target, product, alternatives) {
  const dims = Object.keys(target.weights).filter((d) => target.weights[d] > 0);
  const weightedScore = (c) => dims.reduce((sum, d) => sum + target.weights[d] * c.scores[d], 0);
  const productScore = weightedScore(product);
  const rivals = alternatives.map((a) => ({ name: a.name, score: weightedScore(a) }));
  const bestRival = rivals.reduce((a, b) => (b.score > a.score ? b : a));
  const byDimension = dims.map((d) => {
    const rivalBest = alternatives.reduce(
      (best, a) => (a.scores[d] > best.score ? { name: a.name, score: a.scores[d] } : best),
      { name: alternatives[0].name, score: -Infinity }
    );
    return { dimension: d, weight: target.weights[d], productScore: product.scores[d], bestRivalScore: rivalBest.score, bestRivalName: rivalBest.name, wins: product.scores[d] > rivalBest.score };
  });
  return { segment: target.name, productWeightedScore: Number(productScore.toFixed(2)), bestRival: bestRival.name, bestRivalWeightedScore: Number(bestRival.score.toFixed(2)), fitsSegment: productScore > bestRival.score, byDimension };
}

const mercado = { name: 'Mercado', scores: { curatedDiscovery: 9, sellerTrust: 8, catalogBreadth: 6, price: 5, deliverySpeed: 5, convenience: 6 } };
const genericMegastore = { name: 'genericMegastore', scores: { curatedDiscovery: 3, sellerTrust: 4, catalogBreadth: 9, price: 8, deliverySpeed: 9, convenience: 8 } };
const localShop = { name: 'localShop', scores: { curatedDiscovery: 6, sellerTrust: 9, catalogBreadth: 2, price: 4, deliverySpeed: 3, convenience: 3 } };
const alternatives = [genericMegastore, localShop];

const explorers = { name: 'explorers', weights: { curatedDiscovery: 0.4, sellerTrust: 0.3, catalogBreadth: 0.1, price: 0.1, deliverySpeed: 0.05, convenience: 0.05 } };

const positioningStatement = {
  targetSegment: 'buyers who browse without knowing exactly what they\'re looking for',
  need: 'they get tired of running the same search on a generic search engine and only finding more of the same',
  productCategory: 'the curated-discovery marketplace',
  keyBenefit: 'surprises you with something you didn\'t know you wanted, backed by trusted local sellers',
  competitiveAlternative: 'a generic megastore, optimized for finding fast what you already know you want',
  differentiator: 'Mercado optimizes for the moment when you still don\'t know what it is you want',
};

console.log('=== whereToPlay: positionFit for the chosen segment ===\n');
const whereToPlay = positionFit(explorers, mercado, alternatives);
console.log(`segment: ${whereToPlay.segment} | productWeightedScore: ${whereToPlay.productWeightedScore} | bestRival: ${whereToPlay.bestRival} (${whereToPlay.bestRivalWeightedScore}) | fitsSegment: ${whereToPlay.fitsSegment} | margin: ${(whereToPlay.productWeightedScore - whereToPlay.bestRivalWeightedScore).toFixed(2)}\n`);
console.table(whereToPlay.byDimension.map((d) => ({ dimension: d.dimension, weight: d.weight, product: d.productScore, bestRival: `${d.bestRivalName}:${d.bestRivalScore}`, wins: d.wins })));

console.log('\n=== The complete positioning statement (Dunford\'s 5 pieces) ===\n');
console.log(`For ${positioningStatement.targetSegment}, who ${positioningStatement.need}, Mercado is ${positioningStatement.productCategory} that ${positioningStatement.keyBenefit}. Unlike ${positioningStatement.competitiveAlternative}, ${positioningStatement.differentiator}.`);

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

=== whereToPlay: positionFit for the chosen segment ===

segment: explorers | productWeightedScore: 7.65 | bestRival: localShop (6) | fitsSegment: true | margin: 1.65

┌─────────┬────────────────────┬────────┬─────────┬──────────────────────┬───────┐
│ (index) │     dimension      │ weight │ product │      bestRival       │ wins  │
├─────────┼────────────────────┼────────┼─────────┼──────────────────────┼───────┤
│    0    │ 'curatedDiscovery' │  0.4   │    9    │    'localShop:6'     │ true  │
│    1    │   'sellerTrust'    │  0.3   │    8    │    'localShop:9'     │ false │
│    2    │  'catalogBreadth'  │  0.1   │    6    │ 'genericMegastore:9' │ false │
│    3    │      'price'       │  0.1   │    5    │ 'genericMegastore:8' │ false │
│    4    │  'deliverySpeed'   │  0.05  │    5    │ 'genericMegastore:9' │ false │
│    5    │   'convenience'    │  0.05  │    6    │ 'genericMegastore:8' │ false │
└─────────┴────────────────────┴────────┴─────────┴──────────────────────┴───────┘

=== The complete positioning statement (Dunford's 5 pieces) ===

For buyers who browse without knowing exactly what they're looking for, who get tired of running the same search on a generic search engine and only finding more of the same, Mercado is the curated-discovery marketplace that surprises you with something you didn't know you wanted, backed by trusted local sellers. Unlike a generic megastore, optimized for finding fast what you already know you want, Mercado optimizes for the moment when you still don't know what it is you want.

Mercado wins the explorers segment by a margin of +1.65, losing four of six individual dimensions and winning only in curatedDiscovery — but that single dimension weighs 0.4, more than the other five combined. Now run the same model against the segment Mercado decided not to pursue:

const exactSkuShoppers = { name: 'exactSkuShoppers', weights: { curatedDiscovery: 0, sellerTrust: 0, catalogBreadth: 0.1, price: 0.35, deliverySpeed: 0.35, convenience: 0.2 } };

console.log('=== whereToPlay: the EXCLUDED segment, does it really lose? ===\n');
const excluded = positionFit(exactSkuShoppers, mercado, alternatives);
console.log(`segment: ${excluded.segment} | productWeightedScore: ${excluded.productWeightedScore} | bestRival: ${excluded.bestRival} (${excluded.bestRivalWeightedScore}) | fitsSegment: ${excluded.fitsSegment} | margin: ${(excluded.productWeightedScore - excluded.bestRivalWeightedScore).toFixed(2)}\n`);
console.table(excluded.byDimension.map((d) => ({ dimension: d.dimension, weight: d.weight, product: d.productScore, bestRival: `${d.bestRivalName}:${d.bestRivalScore}`, wins: d.wins })));

What to expect.

=== whereToPlay: the EXCLUDED segment, does it really lose? ===

segment: exactSkuShoppers | productWeightedScore: 5.3 | bestRival: genericMegastore (8.45) | fitsSegment: false | margin: -3.15

┌─────────┬──────────────────┬────────┬─────────┬──────────────────────┬───────┐
│ (index) │    dimension     │ weight │ product │      bestRival       │ wins  │
├─────────┼──────────────────┼────────┼─────────┼──────────────────────┼───────┤
│    0    │ 'catalogBreadth' │  0.1   │    6    │ 'genericMegastore:9' │ false │
│    1    │     'price'      │  0.35  │    5    │ 'genericMegastore:8' │ false │
│    2    │ 'deliverySpeed'  │  0.35  │    5    │ 'genericMegastore:9' │ false │
│    3    │  'convenience'   │  0.2   │    6    │ 'genericMegastore:8' │ false │
└─────────┴──────────────────┴────────┴─────────┴──────────────────────┴───────┘

The one-pager's whereToPlay layer is thus confirmed in the two directions that matter: it wins where it chose to play (margin +1.65), and it loses —unambiguously, without winning a single dimension— where it decided not to play (margin −3.15). That asymmetry —a narrow, calculated win against a total, unappealable loss— is exactly the signature of a well-chosen "where to play," not a coincidence of these numbers.

Deep dive: why this layer doesn't repeat module 3, it cites it

Notice that this lesson didn't re-explain what a beachhead is, or why a job-to-be-done defines a segment better than demographics, or how a positioning statement is built with Dunford's five pieces — you already learned all of that, thoroughly, in module 3's six lessons. What this lesson does is different: it cites that module's already-verified result, in the exact place it belongs within the larger document. That's the difference between a real one-pager and a collection of summaries — a summary re-explains; a one-pager layer reuses the work already done, without rewriting it, and adds only what's needed to connect it to the neighboring layers.

This pattern repeats in each of the following lessons: lesson 4 doesn't re-explain what parity is or what the competitive map is, it runs differentiationMap and competitiveMap on the same data from modules 4 and 5. Lesson 5 doesn't re-explain the five moat types, it runs moatScore on module 6's inventory. Every layer of the one-pager is a verified citation, not a rereading.

Common mistakes

Redefining the segment "a bit differently" while assembling the one-pager. What happens: someone, while building this layer, slightly tweaks explorers's weights or changes one of the alternatives —"so it looks better in the final document"—, without realizing the one-pager no longer describes the same strategy the rest of the guide verified. Why it happens: the one-pager feels like an opportunity to "polish" the final result, and a small number tweak seems harmless compared to rewriting all the logic. How to spot it: compare this layer's data, field by field, against module 3's project (08-project-mercados-target-and-positioning.md) — if anything doesn't match exactly, someone "improved" the data without running the full verification again. How to fix it: this layer gets copied verbatim, no exceptions. If the segment genuinely needs to change, that change belongs to module 3, not this one-pager, and should propagate backward, not happen only here.

Showing only the chosen segment, without the excluded one, "to not complicate the document." What happens: the final one-pager only includes the explorers table winning, and omits the verification that exactSkuShoppers really loses — the same mistake module 3 already warned about at the project level, now repeated at the one-pager level. Why it happens: showing only the win feels cleaner and more persuasive than also showing the complete comparison. How to spot it: if your one-pager can't answer, with an exact number, "why DIDN'T we also pursue exact-SKU buyers, if they're a bigger market?", the layer is incomplete. How to fix it: always include both runs, as in this lesson — the strength of "where we play" lies as much in where we win as in where, honestly, we don't.

Treating fitsSegment: true as the end of the strategy conversation. What happens: seeing that Mercado wins the chosen segment, the team considers the "where to play" work closed and moves straight to building, without yet asking how defensible that win is over time. Why it happens: a positive result feels like a conclusion, when in reality it's only the first of four layers the complete one-pager needs. How to spot it: if your team celebrates positionFit's result without yet mentioning the word "differentiation" or "moat," most of the one-pager is missing. How to fix it: remember that positionFit measures a snapshot of today — Mercado wins now, with current scores. Lessons 4 and 5 complete the question of whether that advantage is real and whether it's defensible over time.

Exercises

Exercise 1 — Recalculate the margin with a stronger rival. If localShop improved its sellerTrust from 9 to 10 (the maximum possible), would bestRival change for the explorers segment, and would the final fitsSegment change? Calculate localShop's new productWeightedScore by hand before answering.

See solution

localShop's productWeightedScore with sellerTrust: 10 would be: 0.4×6 + 0.3×10 + 0.1×2 + 0.1×4 + 0.05×3 + 0.05×3 = 2.4 + 3.0 + 0.2 + 0.4 + 0.15 + 0.15 = 6.3. It's still below Mercado in curatedDiscovery (Mercado wins that dimension with more weight), so localShop would still be the bestRival (now with 6.3 instead of 6), and fitsSegment would still be true, though Mercado's margin would shrink from 1.65 to 1.35. The result doesn't change sign, but it does change magnitude — an early warning that, if localShop keeps improving its perceived trust, Mercado's margin could eventually reverse.

Exercise 2 — Verify a third hypothetical segment. A bargainHunters segment has weights: { curatedDiscovery: 0, sellerTrust: 0.1, catalogBreadth: 0.2, price: 0.5, deliverySpeed: 0.1, convenience: 0.1 }. Without running anything, predict whether fitsSegment would be true or false for Mercado, and how large you'd expect the margin to be compared to exactSkuShoppers (−3.15).

See solution

fitsSegment would be false, and the margin would be negative and of similar or greater magnitude than exactSkuShoppers — this segment weighs price even more heavily (0.5 versus 0.35) and gives no weight at all to curatedDiscovery, the only dimension where Mercado clearly wins. It's, if anything, an even less favorable case for Mercado than exactSkuShoppers: it shares the same pattern (zero weight on Mercado's strength) but concentrates even more weight on price, the dimension where genericMegastore dominates unchallenged.

Exercise 3 — Connect to lesson 4. This lesson's positioning statement names curatedDiscovery as part of the key benefit, but positionFit measures whether Mercado wins today, not whether that advantage is hard to copy. Write, in 2-3 sentences, what different question lesson 4 is going to answer about this same dimension.

See solution

positionFit answered "does Mercado win on curatedDiscovery against today's alternatives, with current scores?" — and the answer was yes, with enough margin to win the whole segment. Lesson 4 is going to ask something different: of the six dimensions where Mercado competes, which are real differentiation —at least a 2-point advantage over the best rival— and which are just parity disguised as an advantage? It's the difference between "we win today" (this lesson) and "that win is solid, not a technical tie that looks like an advantage" (the next one).

Summary and next step

In this lesson you filled the one-pager's second layer: whereToPlay, verified with positionFit in the two directions that matter — the chosen segment wins with a +1.65 margin, and the explicitly excluded segment loses with a −3.15 margin, no ambiguity. The complete positioning statement, with Dunford's five pieces, is set as part of this layer.

Before moving on you should be clear on: why whereToPlay has to exist before howToWin, and why verifying the excluded segment matters as much as verifying the chosen one.

Lesson 4 fills the third layer: how Mercado wins on the ground it just confirmed, with differentiationMap separating real differentiation from parity, and with module 5's complete competitive landscape as context for how long that advantage is going to last.

Resources

← PreviousThe strategy one-pagerNext →How to win