Module 3: Target And Positioning

Who is this for -- and who is it NOT for

Next →

Description

"Who is Mercado's user?" has an easy answer and a useful answer, and they're almost always different. The easy answer: "anyone who buys something online" — technically true, and completely useless, for the same reason "any road works" was a useless GPS answer in module 2. The useful answer demands something more uncomfortable: naming, precisely, who this is for — and saying, out loud, who it's NOT for, even if that second person also buys online, also has money, and would also, in any sales meeting, be a welcome customer.

This lesson builds positionFit, the module's central model: it compares Mercado against two real alternatives — a generic megastore and a local shop — but using a specific segment's importance weights, not a universal "who's better" score. The result, run twice with the same product, is the whole lesson summed up in two numbers: Mercado wins for one type of buyer and clearly loses for another. Choosing the target segment isn't describing "your ideal customer" on a slide — it's accepting, with data, that the same product is going to lose against other, equally real buyers, and choosing that loss on purpose.

Connection to the module. The module intro showed you the final result without explaining it. This lesson opens the box: why Mercado wins for explorers and why it loses for exactSkuShoppers, dimension by dimension. This same pair of segments — the one that wins and the one that structurally can't win — will reappear in lesson 3 (to show that not even "all average buyers" is a good target) and in the lesson 8 project, now on top of the complete positioning statement.

An everyday analogy: the tailored suit and the poncho for everyone

A tailor who makes custom suits measures your exact body, cuts the fabric for your exact shoulders, and the result is a suit that fits you better than anything bought at a department store. That same suit, put on someone else with different shoulders, looks bad — not because the tailor did poor work, but because a tailored suit, by definition, fits one person perfectly and almost everyone else badly. That is, precisely, the source of its value: if the tailor tried to cut a suit that fit "reasonably well" on any body, they'd end up with a poncho — a garment nobody finds uncomfortable, and that nobody finds especially good either.

A product that tries to serve "everyone" is that poncho. It doesn't fit anyone badly, and for that same reason, it doesn't fit anyone spectacularly either — and in a market with alternatives, "reasonably good for everyone" loses to "perfect for someone" every time that someone has to decide who to buy from. Choosing a target segment is, literally, deciding which specific body you're going to cut the fabric for — knowing, in advance, that the suit is going to fit different bodies badly, and accepting that consequence instead of trying to avoid it with a half-hearted compromise.

Worked example: the same Mercado, two verdicts, dimension by dimension

positionFit doesn't just say whether a product wins or loses for a segment — it says why, dimension by dimension, always comparing against the best rival on that specific dimension (not against an average). Let's run the complete model, with the per-dimension breakdown, for the same two segments from the module intro.

// positionFit(target, product, alternatives): evaluates whether `product`
// serves `target`'s job BETTER than the alternatives, using THAT segment's
// WEIGHTS -- not a generic score. Also returns the per-dimension breakdown:
// which one Mercado wins, which one the rival wins, and which rival.
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 exactSkuShoppers = { name: 'exactSkuShoppers', weights: { curatedDiscovery: 0, sellerTrust: 0, catalogBreadth: 0.1, price: 0.35, deliverySpeed: 0.35, convenience: 0.2 } };

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

console.log('\n=== positionFit: exactSkuShoppers ===\n');
const r2 = positionFit(exactSkuShoppers, mercado, alternatives);
console.log(`segment: ${r2.segment} | productWeightedScore: ${r2.productWeightedScore} | bestRival: ${r2.bestRival} (${r2.bestRivalWeightedScore}) | fitsSegment: ${r2.fitsSegment}\n`);
console.table(r2.byDimension.map((d) => ({ dimension: d.dimension, weight: d.weight, product: d.productScore, bestRival: `${d.bestRivalName}:${d.bestRivalScore}`, wins: d.wins })));

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

=== positionFit: explorers ===

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

┌─────────┬────────────────────┬────────┬─────────┬──────────────────────┬───────┐
│ (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 │
└─────────┴────────────────────┴────────┴─────────┴──────────────────────┴───────┘

=== positionFit: exactSkuShoppers ===

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

┌─────────┬──────────────────┬────────┬─────────┬──────────────────────┬───────┐
│ (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 │
└─────────┴──────────────────┴────────┴─────────┴──────────────────────┴───────┘

Look calmly at what the breakdown reveals, because it's the lesson's entire point: for explorers, Mercado only wins on ONE of the six dimensions — curatedDiscovery, at 9 against the best rival's 6. On the other five, Mercado loses, some by large margins (catalogBreadth: 6 against 9). And yet, fitsSegment: true — Mercado wins the whole segment. Why? Because that single dimension where it wins carries weight 0.4 — 40% of what matters to this buyer — while the five dimensions where it loses add up to only 0.6 of combined weight, spread across small pieces. Winning big on what matters most is worth more than losing a little on five things that barely matter.

For exactSkuShoppers, the story flips completely. Mercado doesn't even show up in curatedDiscovery or sellerTrust — this segment assigns them weight 0, they literally don't matter to it, so the model doesn't even evaluate them. What does matter to it (price, deliverySpeed, at 0.35 each) is exactly where Mercado is weakest against the generic megastore. There's no dimension where Mercado wins for this buyer — it loses all four, and it loses the whole segment, 5.3 against 8.45. This isn't a close tie a bit more effort would fix: it's a structural defeat, because the product was never built with this job in mind.

Going deeper: "could buy it" is not the same as "is our segment"

Almost anyone with a credit card could, technically, buy on Mercado. That's total addressable market, and it's a real figure that matters to an investor. But "could buy" isn't the question this module answers — the question is "who does Mercado work better for than the alternatives, today, as it's built?" — and that question, as you just saw run, has a very different answer depending on the buyer. exactSkuShoppers could buy on Mercado. They could even have an acceptable experience. But as long as the generic megastore exists and clearly beats it on the four dimensions that buyer cares about, every peso Mercado spends trying to win them over is a poorly invested peso — there's a structurally better-positioned rival for that specific job.

Choosing the target segment, then, isn't a demographic description ("women aged 25-40, urban, middle income") — it's a choice of which specific job you're going to be the best option in the market for, knowing that means not being the best option for other, equally legitimate jobs. Lesson 4 deepens this idea with the full jobs-to-be-done vocabulary; for now, hold onto the question positionFit answers: not "who could buy it?", but "who do we win for?"

Common mistakes

Wanting to be "for everyone" and ending up being for no one. What happens: when defining the target segment, the team avoids naming exclusions because "we don't want to shut the door on anyone," and ends up with a description so broad ("anyone who wants to buy something online") that it fits any person on the planet. Why it happens: naming who you're NOT for feels like losing potential sales, even though in practice those sales were never guaranteed — it just felt more comfortable not to say it out loud. How to spot it: ask whether your target segment could describe, without changing a word, your entire industry's competition. If "anyone who buys online" also perfectly describes the generic megastore's customer, you didn't choose anything — you described the entire market. How to fix it: use positionFit as an acid test — if you can't name at least one real segment your product clearly loses for (like exactSkuShoppers loses here), your definition of "who it's for" is probably still a poncho, not a tailored suit.

Confusing "could buy it" (potential market) with "is our segment" (who we serve best). What happens: the size of the potential market (every online buyer in the region) gets presented as if it were the target segment, without distinguishing between "who could walk through the door" and "who we build the store for." Why it happens: a large potential market sounds better in an investor pitch than a narrow segment, even if the narrow segment is the only part of that market where the product genuinely wins. How to spot it: you saw exactSkuShoppers in the worked example — they're, without a doubt, part of Mercado's potential market (they buy online, they have money, they exist), and yet positionFit clearly rules them out as a target segment. If your "target segment" doesn't distinguish between these two things, you confused the size of the ocean with the exact spot where your boat floats best. How to fix it: reserve "potential market" for the size of the opportunity, and "target segment" only for the portion of that market where positionFit (or its equivalent in human judgment) would return true.

Defining the segment so vaguely that you can't name, with the same clarity, who it excludes. What happens: the target segment gets written with adjectives ("demanding buyers," "quality customers") that sound specific but don't let you say, unambiguously, who's left out. Why it happens: vague adjectives are easy to write and hard to object to — nobody argues with "we want demanding customers," because the sentence commits to nothing verifiable. How to spot it: ask someone on the team to tell you, from the segment definition, which specific buyer would be excluded. If they hesitate, or name something as obvious as "someone with no money," the definition lacks the necessary edge. How to fix it: define the segment by the job it best solves (as in the worked example: explorers, people who don't know exactly what they're looking for) and explicitly name its opposite (exactSkuShoppers, people who know exactly which SKU they want). A segment with no named opposite isn't a choice — it's an aspiration with no edge, the same mistake module 1 called bad strategy.

Exercises

Exercise 1 — Predict before running. A third segment, bargainHunters, defines its weights like this: { curatedDiscovery: 0, sellerTrust: 0, catalogBreadth: 0.15, price: 0.55, deliverySpeed: 0.15, convenience: 0.15 }. Without running anything, predict: would positionFit return fitsSegment: true or false for Mercado against this segment? Justify with at least one specific dimension.

See solution

fitsSegment: false. The dominant weight (0.55) falls on price, the dimension where Mercado is weakest against the generic megastore (5 against 8) — and curatedDiscovery, the only dimension where Mercado wins, has weight 0 for this segment, so it doesn't even get evaluated. It's, in essence, a variation on exactSkuShoppers: another buyer for whom Mercado structurally loses, because what matters to them (price) is exactly where the generic megastore dominates.

Exercise 2 — Design a new segment where Mercado wins even more. Write the weights for a fourth segment, different from explorers, for which positionFit would return fitsSegment: true with an even bigger margin than 1.65 (7.65 − 6, explorers's margin). Hint: look at which dimension has the weakest best-rival compared to Mercado.

See solution

A reasonable option: a segment that values almost exclusively sellerTrust and curatedDiscovery (where Mercado scores 8 and 9) and almost nothing else, for example { curatedDiscovery: 0.5, sellerTrust: 0.4, catalogBreadth: 0.05, price: 0.05, deliverySpeed: 0, convenience: 0 }. The worst rival on sellerTrust is localShop at 9 (Mercado loses there, 8 against 9), but the dominant weight is still on curatedDiscovery, where Mercado wins by the biggest margin of the six dimensions (9 against 6). Running positionFit with these weights should give a productWeightedScore higher than 7.65, confirming the intuition: concentrating weight on the dimension with the biggest winning margin produces the strongest fit.

Exercise 3 — Defend the exclusion to sales. A coworker from Mercado's sales team asks why the product team isn't investing in attracting exactSkuShoppers, "since they're already buying online anyway." Write, in 2-3 sentences, your answer using this lesson's exact vocabulary (segment vs. potential market, the weight-0 dimension, structural defeat).

See solution

An example answer: "You're right that they're part of our potential market — anyone with a credit card is. But they're not our target segment: for someone searching for an exact SKU, curatedDiscovery and sellerTrust — exactly where Mercado is strongest — are worth zero, and what does matter to them — price and delivery speed — is exactly where the generic megastore clearly beats us. It's not that we're lacking marketing effort there — it's a structural defeat given how the product is built. Every peso we spend on that buyer is a peso we don't invest in explorers, where we do win with a real margin."

Summary and next step

The target segment isn't a list of who could buy your product — it's a choice, backed by data, of who your product wins for against the real alternatives, accepting that the same choice means losing against other, equally legitimate buyers. You saw positionFit run twice on the same Mercado: it clearly wins for explorers (winning on a single dimension, but the one that carries the most weight), and it clearly loses for exactSkuShoppers (losing on all four dimensions that buyer cares about). That asymmetry, not a nice demographic description, is what defines a real target segment.

Before moving on you should be able to: explain why "could buy it" isn't the same as "is our segment"; and name, for any product you know, a real buyer for whom that product structurally loses.

Lesson 3 takes this same pair of segments and adds a third comparison — the "average" buyer, with no specific segment — to show something even more uncomfortable: not even targeting "all buyers equally" is a winning bet. There you'll meet Geoffrey Moore's beachhead: why narrow, chosen with precision, beats wide, chosen by default.

Resources

  • April Dunford, Obviously Awesome — aprildunford.com/books. The chapter on "best competitive alternative" is, in essence, the same exercise positionFit automates: comparing against what the segment would use if your product didn't exist. In English.
  • Clayton M. Christensen and Taddy Hall, "Know Your Customers' Jobs to Be Done" — hbr.org/2016/09/know-your-customers-jobs-to-be-done. The distinction between "who" (demographics) and "what job" is this article's central argument, and it anticipates exactly this lesson's third common mistake. In English.
  • Marty Cagan (SVPG), "Product Market Fit" — svpg.com/product-market-fit. Cagan describes the same pattern from the product side: win one segment (persona or vertical) at a time, instead of chasing everyone simultaneously. In English.
  • Roger Martin, "Decoding the Strategy Choice Cascade" — rogermartin.medium.com/decoding-the-strategy-choice-cascade-475d40555eb1. "Where do we play?" is, in Martin's vocabulary, the same question this lesson answers at the segment level — and "where we play" always implies, with the same force, where we don't. In English.
← PreviousModule overview: from the summit to the first concrete choiceNext →The beachhead: narrow before wide