Module 4: Differentiation And Value Prop

Parity vs. differentiation: table stakes are not an advantage

Next →

Description

Parity is everything a player needs just to be taken seriously on a playing field — the minimum entry bar, what's expected of anyone competing there. Differentiation is what a player has that others don't — or has much better — and that therefore tips the choice in their favor. The confusion between the two is, by far, this module's most expensive mistake: an entire team can spend a whole year investing in something, feel like it's gaining ground, and discover it only reached parity — the level everyone has to be at to be considered, not the level at which someone chooses you.

In lesson 1 you saw two loose dimensions — price and curated discovery — and a first clue: winning on a dimension isn't the same as that dimension mattering to the segment. This lesson builds the complete model, with Mercado's positioning's five real dimensions, and gives precise names to the two questions you have to ask each one: do we win, or just tie? and does anyone care about the result?

Connection to the module. This is the module's foundational lesson: the complete differentiationMap, with its decision margin and its four possible verdicts, appears here for the first time and gets reused, with different data, in every lesson that follows.

An everyday analogy: the poker table

At a poker table, before a single card gets dealt, every player has to put in the ante — the mandatory minimum bet to sit down and play. Putting in the ante doesn't move you an inch closer to winning the hand: it's, literally, the price of admission. Everyone at the table pays it, no exceptions, and nobody wins a hand for having paid it. The phrase that names this lesson comes from there: in business, the capabilities every serious player has to have — the equivalent of the ante — are called table stakes.

What wins the hand is something else entirely: the cards you hold, how you read your rivals, when you bet big and when you fold — skills and advantages not everyone at the table has to the same degree. A player who brags about "never failing to put in the ante" isn't saying anything — everyone at that table puts in the ante, always, or they get taken out of the game. Bragging about that is exactly the mistake this lesson teaches you to spot: confusing the cost of entry with the reason for winning.

Mercado, the generic giant, and the neighborhood shop play the same table. All of them have to put in a certain ante — deliver orders in a reasonable time, have a checkout that works, not lose the buyer's money — just to be considered at all. None of those antes decides who wins the hand.

Worked example: Mercado's complete differentiation map

We compare Mercado against its two module-3 alternatives — the generic giant and the neighborhood shop — on five dimensions: how broad the catalog is, price, delivery speed, curated discovery, and trust in local sellers. Each dimension carries, besides the score, whether it matters or not to the browsing segment you chose in module 3 — the model doesn't invent that data, it comes from the segment research you already did.

function differentiationMap(us, competitors, dimensions) {
  const REAL_DIFF_MARGIN = 2;
  return dimensions.map((dim) => {
    const usScore = us.scores[dim.key];
    const rivals = competitors.map((c) => ({ name: c.name, score: c.scores[dim.key] }));
    const best = rivals.reduce((a, b) => (b.score > a.score ? b : a));
    const gap = usScore - best.score;
    let verdict;
    if (gap >= REAL_DIFF_MARGIN) verdict = 'differentiation';
    else if (gap <= -REAL_DIFF_MARGIN) verdict = 'gap';
    else verdict = 'parity';
    return {
      dimension: dim.key,
      mattersToSegment: dim.matters,
      usScore,
      bestCompetitor: best.name,
      bestCompetitorScore: best.score,
      verdict,
    };
  });
}

const mercado = {
  name: 'Mercado',
  scores: { catalogBreadth: 3, price: 3, deliverySpeed: 4, curatedDiscovery: 5, localSellerTrust: 5 },
};

const genericMegastore = {
  name: 'genericMegastore',
  scores: { catalogBreadth: 5, price: 5, deliverySpeed: 4, curatedDiscovery: 2, localSellerTrust: 2 },
};

const neighborhoodShop = {
  name: 'neighborhoodShop',
  scores: { catalogBreadth: 1, price: 3, deliverySpeed: 2, curatedDiscovery: 3, localSellerTrust: 3 },
};

const dimensions = [
  { key: 'catalogBreadth', matters: false },
  { key: 'price', matters: false },
  { key: 'deliverySpeed', matters: true },
  { key: 'curatedDiscovery', matters: true },
  { key: 'localSellerTrust', matters: true },
];

console.log('=== Mercado vs. genericMegastore vs. neighborhoodShop ===\n');
const results = differentiationMap(mercado, [genericMegastore, neighborhoodShop], dimensions);
console.table(results);

const realDiffs = results.filter((r) => r.verdict === 'differentiation' && r.mattersToSegment);
const tableStakes = results.filter((r) => r.verdict === 'parity' && r.mattersToSegment);
const irrelevantGaps = results.filter((r) => r.verdict === 'gap' && !r.mattersToSegment);

console.log(`\nReal differentiation (we win, and the segment cares): ${realDiffs.length}/${dimensions.length}`);
console.log(`Table stakes (matters, but we're even): ${tableStakes.length}/${dimensions.length}`);
console.log(`Irrelevant gaps (we lose, but the segment doesn't care): ${irrelevantGaps.length}/${dimensions.length}`);

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

=== Mercado vs. genericMegastore vs. neighborhoodShop ===

┌─────────┬────────────────────┬──────────────────┬─────────┬────────────────────┬─────────────────────┬───────────────────┐
│ (index) │     dimension      │ mattersToSegment │ usScore │   bestCompetitor   │ bestCompetitorScore │      verdict      │
├─────────┼────────────────────┼──────────────────┼─────────┼────────────────────┼─────────────────────┼───────────────────┤
│    0    │  'catalogBreadth'  │      false       │    3    │ 'genericMegastore' │          5          │       'gap'       │
│    1    │      'price'       │      false       │    3    │ 'genericMegastore' │          5          │       'gap'       │
│    2    │  'deliverySpeed'   │       true       │    4    │ 'genericMegastore' │          4          │     'parity'      │
│    3    │ 'curatedDiscovery' │       true       │    5    │ 'neighborhoodShop' │          3          │ 'differentiation' │
│    4    │ 'localSellerTrust' │       true       │    5    │ 'neighborhoodShop' │          3          │ 'differentiation' │
└─────────┴────────────────────┴──────────────────┴─────────┴────────────────────┴─────────────────────┴───────────────────┘

Real differentiation (we win, and the segment cares): 2/5
Table stakes (matters, but we're even): 1/5
Irrelevant gaps (we lose, but the segment doesn't care): 2/5

Five dimensions, and all five fall into a different pattern, worth reading one by one:

  • catalogBreadth and price are gaps that don't matter: the generic giant clearly wins both (a full two points ahead of Mercado), but the browsing segment — the people you chose to serve in module 3 — doesn't pick where to buy based on the biggest catalog or the lowest price. Losing there isn't a weakness to fix: it's the cost of having chosen a different playing field than the generic giant's. It's also worth noting that competing on price would clash directly with a module 2 vision exclude (lowestPriceRace) — another reason, independent of this model, not to chase it.
  • deliverySpeed is real table stakes: it matters to the segment (nobody wants to wait weeks), and there Mercado is exactly tied with the generic giant (4 against 4) — neither one wins this dimension, both simply paid the ante to sit at the table. Notice the nuance: deliverySpeed does matter, and it's still not an advantage — it's the clearest proof of why "mattering" and "differentiating" are two different questions.
  • curatedDiscovery and localSellerTrust are real differentiation: on both, Mercado beats the best rival (which, in both cases, is the neighborhood shop, not the generic giant) by at least a full two points, and both matter to the segment. This is exactly the differentiation Mercado's design (curated discovery + trusted local sellers) promised since module 2 — and now you have the proof, dimension by dimension, not just the intent.

Going deeper: the complete four-quadrant map

differentiationMap actually produces four possible combinations between verdict and mattersToSegment, even though the example above only showed three. It's worth naming all four, because each one calls for a different reaction:

  1. differentiation + matters: true — real differentiation. This goes straight into your value proposition (lesson 3) and deserves more investment, not less.
  2. parity + matters: true — real table stakes, like deliverySpeed. It isn't a problem as long as you stay tied or ahead; it does become a problem if any rival pulls ahead there, because then it stops being a tie.
  3. gap + matters: false — irrelevant on purpose, like catalogBreadth and price. Ignore it calmly; chasing it diverts budget from where it actually matters.
  4. differentiation + matters: false — you win, but nobody cares. It didn't show up in this lesson's example on purpose: it's the module's subtlest trap, and lesson 7 devotes a full case to it.

There's one more combination to name, which does not show up on Mercado's map, and it's the most dangerous of the five possible ones: gap + matters: true — losing on something that does matter to the segment. That isn't a gap you can ignore like catalogBreadth: it's a real vulnerability. The fixed margin (REAL_DIFF_MARGIN = 2) is, again, a pedagogical model — it structures judgment, it doesn't replace it: a margin of 2 on a 1-to-5 scale is a reasonable choice for this exercise, not a law of physics. In a real case you'd tune the margin (or the scales) based on how sensitive your market is to small differences.

Common mistakes

Confusing parity with advantage. What happens: someone presents deliverySpeed in a meeting as "our logistics advantage," when the map clearly shows it's tied with the generic giant. Why it happens: meeting a high bar feels like an accomplishment — and it is one — but an accomplishment isn't the same as an advantage over the competition; you feel good about having paid the ante, and that gets confused with having won the hand. How to spot it: for anything someone calls "our advantage," ask what the bestCompetitorScore is on that same dimension — if it's within two points of yours, it isn't an advantage, it's parity. How to fix it: reserve the word "advantage" or "differentiator" exclusively for what the map marks differentiation; for everything else, say "we meet the bar" or "we're at par," which are real accomplishments, just in a different category.

Treating any higher score, with no margin, as differentiation. What happens: Mercado scores 4 on a dimension, the best rival scores 3, and the team announces "we beat them on X" — a one-point difference, within the error margin of any subjective score (surveys, brand perception, user ratings). Why it happens: any higher number feels like a win, and it's more satisfying to announce an advantage than to admit a technical tie. How to spot it: apply the same margin the model uses (REAL_DIFF_MARGIN, set here at 2) consistently — if the difference is smaller than the margin you yourself defined as "real," you can't use it when convenient and ignore it when not. How to fix it: define the differentiation margin before looking at the results, not after — just like in any serious evaluation, deciding the criterion with the data already on the table is the easiest way to fool yourself.

Fighting to close a parity gap instead of deepening differentiation. What happens: seeing that the generic giant has a better catalogBreadth, the team dedicates budget and sprints to "closing the catalog gap" — moving from gap to parity on a dimension that, per the map itself, doesn't matter to the segment. Why it happens: a visible numeric gap (3 against 5) feels like something urgent to fix, far more than continuing to invest in an advantage you already have (curatedDiscovery, already at 5). How to spot it: check the mattersToSegment of any gap before proposing to close it — if it's false, closing it doesn't move the needle on why anyone chooses you. How to fix it: every unit of budget or engineering focus spent tying a dimension that doesn't matter is a unit not spent widening one that does — the map doesn't just tell you where you're even, it tells you where you shouldn't be looking.

Exercises

Exercise 1 — Predict without running the code. Mercado adds a new dimension, customerSupportResponseTime (how fast customer support responds), which does matter to the segment (matters: true). The scores are: Mercado = 3, genericMegastore = 3, neighborhoodShop = 5. Before running anything, predict what verdict differentiationMap would return, and which of the four (or five) quadrants from "going deeper" it belongs to.

See solution

The best rival is neighborhoodShop at 5. Mercado's gap is 3 - 5 = -2, which falls under gap <= -REAL_DIFF_MARGIN (with REAL_DIFF_MARGIN = 2), so the verdict is 'gap', with mattersToSegment: true. This is exactly the dangerous combination "going deeper" named but that didn't show up on Mercado's original map: losing on something that does matter. Unlike catalogBreadth or price, this gap can't be calmly ignored — it's a real vulnerability against the neighborhood shop, which probably wins on support because it knows its customers in person.

Exercise 2 — Defend parity to an impatient coworker. A coworker sees deliverySpeed sitting at parity and proposes investing heavily to beat the generic giant there, "to have one more advantage." Using the poker-table analogy, explain in one paragraph why that — even though it would raise the score — isn't necessarily a bad idea, but isn't free either: what gets sacrificed by moving budget there?

See solution

A reasonable argument: "It isn't a bad idea in a vacuum — turning a parity into a real advantage would indeed be one more point in our favor — but it costs something we're not naming: every engineering hour and every dollar that go into improving deliverySpeed don't go into deepening curatedDiscovery or localSellerTrust, the two dimensions where we genuinely win and where the segment chooses us. At the poker table, spending extra chips paying a higher ante than necessary doesn't give you better cards — it just leaves you with fewer chips for when it truly matters to bet big. If we're going to move deliverySpeed from parity to advantage, it has to be because the segment values it enough to justify that opportunity cost, not because 'one more advantage' sounds good on a slide."

Exercise 3 — Find your own table stakes. Think of a product you use often (an app, a work tool, a service). Name a capability that product (or its entire category) treats as if it were a special achievement, when it's actually something any serious competitor in that category also has — that is, table stakes disguised as differentiation.

See solution

There's no single answer — the exercise evaluates whether you can apply the criterion to a real case. A reference example: almost any banking app advertises "secure, encrypted transfers" as if it were a major differentiator — but in 2026, a bank without secure, encrypted transfers couldn't legally operate or keep a single customer. It's exactly the poker table's ante: mandatory for everyone, and therefore invisible as an advantage to a user comparing banks.

Summary and next step

Parity is what every serious player on a field has to have — the poker table's ante, necessary but incapable of winning the hand by itself. Differentiation is what only you have (or have much better), and that also matters to the segment you chose to serve. With the complete differentiationMap, run against the five dimensions of Mercado's positioning, you saw the pattern that repeats in any real product: some gaps don't matter (ignore them on purpose), some parity does matter (defend it, don't abandon it), and only two of five dimensions turned out to be real differentiation — roughly the same proportion you'll find in most products you audit with this criterion.

Before moving on you should be able to: explain, without using the model's vocabulary, the difference between parity and differentiation in your own words; name the four quadrants that come from crossing verdict with mattersToSegment; and detect, in any sentence starting with "our advantage is...," whether what follows would actually pass the margin test.

Lesson 3 takes exactly the dimensions you marked differentiation here and turns them into something a buyer can read and understand in a single sentence: the value proposition. You're also going to see the most common mistake when writing it — turning it into a feature list, the same underlying mistake you just learned to spot in the gaps that don't matter.

Resources

← PreviousModule overview: why they choose you, and not the usual alternativeNext →What a value proposition IS (and isn't)