Mini-project: Mercado's target segment and positioning statement

Description

It's time to bring the whole module together into a single artifact: Mercado's target segment and positioning statement, verified with data, not just written in good prose. You learned to tell who Mercado is for and who it isn't (L2), to choose a narrow beachhead instead of chasing the average buyer (L3), to define that segment by the job it solves rather than its demographics (L4), to understand positioning as owning a category rather than adding up points (L5), to write it with Moore and Dunford's full template (L6), and to recognize the risk of diluting it by copying the leader (L7). In this project you use positionFit on the complete case — the chosen segment and the explicitly excluded segment, both verified against the same two alternatives — not on isolated fragments like in each lesson.

Your deliverable has two parts, and both are verified with code, not just written out: (1) Mercado's target segment, with its job and explicit weights, and the complete positioning statement with Dunford's five pieces; and (2) the executed proof that segment wins with positionFit — and that the segment you decided NOT to serve genuinely loses, not assumed or by omission, but confirmed with the same model.

Connection to the module. This project introduces no new concept — it gathers, in a single verified document, everything you built lesson by lesson. It's also the second link in an arc that started with module 2's vision and continues through the rest of this guide: the segment and positioning you define here are the base module 4 is going to build differentiation and value proposition on top of — the question "what makes you different and better for this specific segment?", which only makes sense once the segment and category are already fixed, as they are by the close of this project.

An analogy: the store's identity card, before decorating the space

Before choosing the wall color, the background music, or the logo design, any serious store owner fills out a much less glamorous card: exactly who's going to walk through that door, what that person needs when they come in, and the short sentence the owner would use to explain to a neighbor "this is what we sell, and why it isn't the same as the store on the corner." That card isn't decoration — it's what determines, afterward, every decorating decision: if the card says "buyers who browse without knowing what they're looking for," the store gets organized for casual discovery; if it said "buyers who already know exactly which SKU they need," it would be organized for efficiency and speed, and it would be a completely different store.

This mini-project is that card, complete and put to the test, for Mercado — the document anyone new on the team should be able to read, the next time someone proposes a product decision, to answer immediately: does this serve the segment we chose, or does it move us away from the category we already earned?

The reference solution, verified

Part 1 — Mercado's segment and positioning statement

This is the synthesis of the module's six lessons, gathered into a single object with the segment (name, job, weights, and its explicitly excluded opposite) and the complete positioning statement with Dunford's five pieces:

const mercadosTargetAndPositioning = {
  segment: {
    name: 'explorers',
    job: 'I need to discover something I didn\'t know I wanted, without knowing exactly what to look for, and trust whoever sells it to me.',
    weights: { curatedDiscovery: 0.4, sellerTrust: 0.3, catalogBreadth: 0.1, price: 0.1, deliverySpeed: 0.05, convenience: 0.05 },
    explicitlyNotFor: 'exactSkuShoppers -- buyers who already know the exact SKU and only prioritize price and speed',
  },
  positioningStatement: {
    targetSegment: 'buyers who browse without knowing exactly what they\'re looking for',
    need: 'they\'re 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 quickly finding what you already know you want',
    differentiator: 'Mercado optimizes for the moment when you don\'t yet know what you want',
  },
};

Verify each piece against the module's criteria before continuing: the segment is defined by a job, not demographics (lesson 4); its weights leave dimensions at 0.05, nearly irrelevant, not spread evenly like lesson 3's allShoppersAverage; it explicitly names who it excludes, with the same precision as who it includes (lesson 2); and the positioning statement completes Dunford's five pieces, leaving none implicit (lesson 6).

Part 2 — The verification, run in Node

Now we run the entire module against the complete case: positionFit confirms the chosen segment wins, and the explicitly excluded segment loses — the two halves of "who it's for, and who it isn't" from lesson 2, verified together, not just asserted in prose.

// PROJECT: Mercado's target segment and positioning statement, verified
// with positionFit -- the module's model -- applied to the complete case:
// the chosen segment (must win) AND the explicitly excluded segment (must
// lose), both against the same two real 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 exactSkuShoppers = { name: 'exactSkuShoppers', weights: { curatedDiscovery: 0, sellerTrust: 0, catalogBreadth: 0.1, price: 0.35, deliverySpeed: 0.35, convenience: 0.2 } };

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

console.log('\n=== PART 2b: 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. Running the file with Node, the output is exactly this:

=== PART 2a: the chosen segment -- does it really win? ===

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 │
└─────────┴────────────────────┴────────┴─────────┴──────────────────────┴───────┘

=== PART 2b: 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 result: the chosen segment wins by 1.65, and the explicitly excluded segment loses by −3.15 — a margin almost twice as big, in the opposite direction. This isn't chance or an ambiguous result: it's the data proof that Part 1's positioning statement isn't an aspirational sentence — it describes something positionFit confirms in both directions that matter. Notice, too, something only visible when comparing both tables: in explorers, Mercado loses four of six dimensions and still wins the whole segment, because the one it wins carries weight 0.4. In exactSkuShoppers, Mercado loses all four dimensions that exist for that segment, winning none — there's no foothold at all, not even a partial one. That difference in shape — a partial, compensated defeat against a total, uncompensated one — is the exact fingerprint of well-chosen positioning: you lose where it doesn't matter, you win where it does, and where you genuinely don't belong, you lose unambiguously.

Common mistakes

Delivering the segment and positioning without running the model against the real alternatives. What happens: the final document includes carefully written prose for the segment and positioning statement, presented as complete, with nobody having run positionFit (or its equivalent in rigorous analysis) against the alternatives' real data — the same mistake lesson 6 already warned about at the level of a single clause, now repeated at the level of the complete deliverable. Why it happens: once the prose sounds convincing and the team approves it in a meeting, verifying it with data feels like an optional extra step, not part of the deliverable itself. How to spot it: ask whether anyone could show, with a concrete number (not an impression), the exact margin by which the chosen segment wins. If nobody can cite that number, the "verified segment" isn't verified yet. How to fix it: no segment-and-positioning deliverable should be considered finished without this project's Part 2 — the executed run, with the exact margin, not just the claim that "we believe we win there."

Not verifying "who it's NOT for" with the same rigor as "who it's for". What happens: the document names, in a sentence, who Mercado does NOT serve (exactSkuShoppers), but never runs positionFit against that segment to confirm it genuinely loses — the exclusion gets assumed, not checked. Why it happens: verifying a win feels like the important work; verifying a loss feels redundant ("obviously we lose there, that's why we excluded it") — the same bias that sometimes led module 2's vision project to skip its excludes. How to spot it: if your segment-and-positioning document doesn't include, with the same detail as Part 2a, an equivalent run against the excluded segment (like this project's Part 2b), half of your verification is only a reasonable assumption, not a confirmed fact. How to fix it: require both runs together, always, as in this project — the chosen segment and the excluded segment, against the same alternatives, in the same document.

Treating this project as the end of the positioning strategy, not its foundation. What happens: closing the project, the team treats it as a finished, filed-away document, without connecting its results to the product decisions that come next — in particular, without asking what it takes for the advantage in curatedDiscovery and sellerTrust to hold over time, instead of being copied by a competitor in a quarter. Why it happens: completing a deliverable with verified data feels like a natural endpoint, and the work of sustaining that advantage over time — real differentiation, not just the current position — seems like a separate topic, for later. How to spot it: if your segment-and-positioning document doesn't end with an open question about how to defend that advantage from being copied, it's incomplete exactly where module 4 begins. How to fix it: remember positionFit measures a snapshot of today — Mercado wins now, with current scores. Whether that advantage holds tomorrow depends on differentiation (how hard it is to copy) and, further into the guide, on moats (how durable it is) — topics this project deliberately leaves open, not resolved.

Exercises

Exercise 1 — Add a third alternative and recalculate. A new competitor, curatedBoutique, enters the market: a hyper-specialized curation boutique, with scores { curatedDiscovery: 8, sellerTrust: 9, catalogBreadth: 1, price: 3, deliverySpeed: 2, convenience: 2 }. Before running anything, predict whether it would change Mercado's bestRival for the explorers segment (which until now was localShop, at 6), and why. Then verify your prediction by calculating curatedBoutique's productWeightedScore by hand.

See solution

Yes, it would change. curatedBoutique is strong exactly on the two dimensions explorers weighs most (curatedDiscovery and sellerTrust, at 0.4 and 0.3), so it should overtake localShop as the strongest rival for this segment. Calculating: 0.4×8 + 0.3×9 + 0.1×1 + 0.1×3 + 0.05×2 + 0.05×2 = 3.2 + 2.7 + 0.1 + 0.3 + 0.1 + 0.1 = 6.5. Indeed, curatedBoutique (6.5) beats localShop (6) and becomes the new bestRival. Mercado still wins (7.65 against 6.5), but the margin shrinks from 1.65 to 1.15 — a rival more specialized in your exact category, even if smaller in scale, is always a more direct threat to your positioning than a distant generalist.

Exercise 2 — Connect toward module 4. This project's positioning statement names curatedDiscovery and sellerTrust as Mercado's key benefit. Module 4 (differentiation-and-value-prop) is going to ask something different from what this module asked: not "do we win today?", but "how hard would it be for the generic megastore to exactly copy this advantage next quarter?" Write, in 2-3 sentences, your initial hypothesis — without using any module 4 framework yet, just intuition informed by what you already know — on whether curatedDiscovery would be easy or hard to copy, and why.

See solution

A reasonable hypothesis: it would probably be hard to copy quickly, because curatedDiscovery at Mercado's score (9) depends on real local sellers with trust relationships built over time (sellerTrust, 8) — it isn't just a software feature the generic megastore could replicate by flipping a feature flag. The megastore would have to recruit and vet a network of trusted local sellers from scratch, something that probably takes years, not a quarter. This intuition — that the advantage depends on a network of relationships, not just code — is exactly the kind of question module 4 is going to formalize with its own executed model, and that module 6 (moats) is going to dig into even further.

Exercise 3 — Defend the complete project to a skeptical growth director. A growth director who didn't take this module reviews the document and asks: "why are we passing up the exactSkuShoppers market — clearly bigger, per industry reports — to stay in a smaller segment?" Write, in one paragraph, how you'd explain the project's full result, citing Part 2's exact numbers (margin 1.65 vs. margin −3.15) and using the module's vocabulary (segment, beachhead, positioning, positioning statement).

See solution

An example answer: "It's not that we're ignoring that market for its size — we evaluated it with the same data we evaluated ours, and we lose there with a margin of −3.15, more than twice as negative as the positive margin we have in explorers (+1.65). It isn't an aesthetic preference for a smaller segment: it's that, as Mercado is built today, we have no real advantage on the dimensions that matter to an exact-SKU buyer — price and delivery speed — while we do have a clear, defensible advantage on discovery and trust, exactly what our positioning statement promises. Chasing that bigger market without fundamentally changing the product would repeat the mistake we already modeled in the module's lesson 7: diluting a won position by chasing one that, with current resources, we can't win. We'd rather consolidate the beachhead we do dominate before considering any expansion — and when we do, it'll be toward a neighboring segment we can win, not the biggest one on a spreadsheet."

Summary and next step

In this mini-project you brought the whole module together into a single verified artifact: Mercado's target segment (explorers), defined by its job and explicit weights; the complete positioning statement with Dunford's five pieces; and the executed proof, with positionFit, that the chosen segment wins with a solid margin (+1.65) while the explicitly excluded segment loses with an even bigger margin (−3.15) — both halves of "who it's for, and who it isn't" confirmed with data, not just asserted. With this you close module 3.

You now have, for any product you work on, a precision question you didn't fully have before: "who do we win for, by what margin, and against what specific alternative?" — and you know the answer needs a number, not just intuition.

Where you go next. You now know where Mercado is headed (module 2) and who it's for, with what positioning (module 3). The question that follows is the one exercise 2 of this project already started anticipating: how defensible is that advantage — what makes you different, and not just different, but better in a way that doesn't get copied in a quarter? That's exactly the question for module 4 (module-04-differentiation-and-value-prop): differentiation and value proposition, the next layer of precision after the segment and positioning you just defined.

Resources

• April Dunford, Obviously Awesome — aprildunford.com/books. The complete five-piece process, now that you have your own version applied start to finish, is worth rereading with Mercado's case fresh. In English.
• Geoffrey Moore, Crossing the Chasm — geoffreyamoore.com/book/crossing-the-chasm. The complete beachhead framework, to compare your own segment choice against Moore's original criteria. 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 reference article behind the job that defines the segment in Part 1 of this project. In English.
• Marty Cagan (SVPG), "Product Market Fit" — svpg.com/product-market-fit. The natural bridge to module 4: once fit with a segment is achieved, the next question is how defensible it is. In English.