Mini-project: audit Mercado's board deck and measure the cost of the wrong sentence

Description

It's time to bring the whole module together into a single exercise. You can tell tactics from strategy (lesson 2), you know what IS and what is NOT a strategy (lesson 3), you put a number on the cost of flawlessly executing the wrong one (lesson 4), you organized the whole vocabulary into four layers (lesson 5), you accepted that the question is yours as an engineer (lesson 6), and you learned to recognize bad strategy even when it's well disguised (lesson 7). In this mini-project you're going to apply all of that, in a single flow, to Mercado's complete board deck — the seven sentences that came out of its two planning offsites, the same ones you met throughout the module.

The project has three parts, and all three are proven by running code, not by describing them in words. First, you audit the complete board deck with isRealStrategy and get the final count: how many of the seven sentences are a real strategy, and how many are bad strategy. Second, you calculate the cost with outcomeOf: you compare what would happen to Mercado if it chased the emptiest sentence in the deck with flawless execution, against chasing the real strategic sentence with barely decent execution. Third, you synthesize both results into a single report, the kind of evidence you'd bring to a meeting to defend why it's worth investing time in properly defining the strategy before building anything.

Connection to the module. This project introduces no new concept: it's the complete synthesis of the seven previous lessons, applied end to end to the case that ran through the whole module. And it sets up the rest of the guide: the "2 of 7 sentences are real strategy" count you're about to confirm here is, exactly, the reason module 2 exists — Mercado needs to build, with rigor, the vision and strategy it's missing, and that starts with the highest of the four layers: vision.

An analogy: the financial audit and the real balance sheet

Before an investor puts money into a company, they don't trust the executive summary the company itself prepared — they request an independent audit that reviews, line by line, the real numbers behind the claims. The audit doesn't invent anything new: it takes the financial statements that already exist and applies a consistent criterion to separate what's true and verifiable from what's optimism with no backing. In the end, the investor has something they didn't have before: a reliable number they can base a decision on.

That is, with total precision, what you're about to do in this project with Mercado's strategy. The seven-sentence board deck is, in a sense, the "executive summary" the Mercado team tells itself about its own direction. This project is the audit: you apply the same consistent criterion (isRealStrategy) to all seven sentences, with no exceptions or favoritism, and get a reliable number — 2 of 7 are real strategy — that Mercado can base its next decision on. And, as in any serious audit, you don't stop at the diagnosis: you also calculate the cost of not fixing it, so the number carries real weight in the conversation that follows.

The reference solution, verified

Let's build the complete audit in three parts. (The exercises at the end ask you to extend it and reason about new cases.)

Part 1 — The complete board deck, audited

We put together the seven sentences that appeared throughout the module: the five from the first offsite (lessons 1 and 3) and the first two from the annual plan (lesson 7) — we deliberately leave out lesson 7's third sentence ("we focus on the customer instead of the competition"), because you already proved it fools the model, and we don't want a false positive distorting this final audit's count.

function isRealStrategy(statement) {
  const text = statement.toLowerCase();
  const tradeoffSignals = ['instead of', 'in place of', 'sacrificing', 'at the cost of', 'we are not going to', 'giving up'];
  const vagueAspirationSignals = ['leading', 'number one', 'world-class', 'the best'];
  const bareGoalPattern = /\d+\s?%/;

  const hasTradeoff = tradeoffSignals.some((s) => text.includes(s));
  const hasVagueAspiration = vagueAspirationSignals.some((s) => text.includes(s));
  const hasBareGoal = bareGoalPattern.test(text);

  if (hasTradeoff) return { verdict: 'strategy', reason: 'declares a choice with an explicit trade-off' };
  if (hasVagueAspiration) return { verdict: 'bad_strategy', reason: 'vague aspiration with no concrete choice' };
  if (hasBareGoal) return { verdict: 'bad_strategy', reason: 'numeric target, not a choice' };
  return { verdict: 'bad_strategy', reason: 'declares no identifiable choice or trade-off' };
}

const boardDeck = [
  'We are going to be the leading marketplace in the region.',
  'This quarter we are going to grow GMV by 30%.',
  'We are going to focus on buyers who browse without knowing what they want, instead of competing for exact-SKU searches where the generic giant already wins.',
  'We want to offer the best shopping experience in the market.',
  'We are not going to build a better search engine than the generic giant; we invest that effort in human curation and trusted local sellers instead.',
  'Our strategy is to maximize omnichannel synergies by leveraging our ecosystem-centric value proposition.',
  'Our objectives are: grow GMV, improve NPS, reduce seller churn, increase buyer retention, and expand into 3 new countries.',
];

console.log('=== Part 1: audit of the complete board deck ===\n');
const audited = boardDeck.map((s, i) => {
  const r = isRealStrategy(s);
  console.log((i + 1) + '. [' + r.verdict.toUpperCase() + '] ' + s);
  return { statement: s, ...r };
});
const realCount = audited.filter((a) => a.verdict === 'strategy').length;
console.log('\n' + realCount + ' of ' + boardDeck.length + ' statements are a real strategy (with a trade-off). The other ' +
  (boardDeck.length - realCount) + ' are bad strategy: goals, aspirations, or fluff with no choice.');

This part holds no surprises for anyone who followed the module closely — it confirms, with a single final count, what you were discovering sentence by sentence in lessons 3 and 7 — but it's exactly the kind of evidence a real audit needs: not a general impression of "our strategy feels a bit vague," but an exact, reproducible, sentence-by-sentence defensible number.

Part 2 — The cost: chasing the empty sentence versus the real sentence

Now the question that gives the whole module its title: if Mercado decided to pursue, with flawless execution, the emptiest sentence in the deck — "be the leading marketplace in the region" — how does that outcome compare against pursuing the deck's one real sentence — "human curation and trusted local sellers" — with barely decent execution, neither perfect nor bad?

function outcomeOf({ strategyQuality, executionQuality }) {
  const strategyCeiling = { right: 100, wrong: 10 };
  const executionFactor = { poor: 0.3, medium: 0.6, great: 1.0 };
  const score = Math.round(strategyCeiling[strategyQuality] * executionFactor[executionQuality]);
  let verdict;
  if (score >= 70) verdict = 'great';
  else if (score >= 40) verdict = 'moderate';
  else if (score >= 15) verdict = 'poor';
  else verdict = 'failing';
  return { score, verdict };
}

console.log('\n=== Part 2: the cost of flawlessly executing the wrong sentence ===\n');
const chaseTheLeaderBet = outcomeOf({ strategyQuality: 'wrong', executionQuality: 'great' });
const chaseCurationBet = outcomeOf({ strategyQuality: 'right', executionQuality: 'medium' });
console.log('Pursuing "be the leader of the region" (bad strategy), executed flawlessly:');
console.log('  score=' + chaseTheLeaderBet.score + ', verdict=' + chaseTheLeaderBet.verdict);
console.log('Pursuing "curation + local sellers" (real strategy), execution barely decent:');
console.log('  score=' + chaseCurationBet.score + ', verdict=' + chaseCurationBet.verdict);
console.log('\nDifference: ' + (chaseCurationBet.score - chaseTheLeaderBet.score) +
  ' points in favor of the real strategy, despite the mediocre execution.');

The choice of "be the leader of the region" as the wrong strategy in this calculation isn't arbitrary: it is, literally, an aspiration with no segment or mechanism named — pursuing it in practice can only mean "grow in every direction at once," which is exactly the same trap the generic giant already dominates with years of head start. Competing there head-on, no matter how perfect the execution, is the very definition of the wrong strategy this entire module has warned about since lesson 2.

Part 3 — The synthesis report

Finally, we bring both results together — the audit count and the calculated cost — into a single object, the kind of summary that would close a real presentation.

console.log('\n=== Part 3: synthesis report ===\n');
const report = {
  strategyStatementsFound: realCount,
  badStrategyStatementsFound: boardDeck.length - realCount,
  worstCase: chaseTheLeaderBet,
  betterCase: chaseCurationBet,
  verdict: chaseCurationBet.score > chaseTheLeaderBet.score
    ? 'the real strategy with mediocre execution beats the perfect execution of the wrong sentence'
    : 'review the model',
};
console.log(report);

What to expect. Running the complete file (all three parts together) with Node, the output is exactly this:

=== Part 1: audit of the complete board deck ===

1. [BAD_STRATEGY] We are going to be the leading marketplace in the region.
2. [BAD_STRATEGY] This quarter we are going to grow GMV by 30%.
3. [STRATEGY] We are going to focus on buyers who browse without knowing what they want, instead of competing for exact-SKU searches where the generic giant already wins.
4. [BAD_STRATEGY] We want to offer the best shopping experience in the market.
5. [STRATEGY] We are not going to build a better search engine than the generic giant; we invest that effort in human curation and trusted local sellers instead.
6. [BAD_STRATEGY] Our strategy is to maximize omnichannel synergies by leveraging our ecosystem-centric value proposition.
7. [BAD_STRATEGY] Our objectives are: grow GMV, improve NPS, reduce seller churn, increase buyer retention, and expand into 3 new countries.

2 of 7 statements are a real strategy (with a trade-off). The other 5 are bad strategy: goals, aspirations, or fluff with no choice.

=== Part 2: the cost of flawlessly executing the wrong sentence ===

Pursuing "be the leader of the region" (bad strategy), executed flawlessly:
  score=10, verdict=failing
Pursuing "curation + local sellers" (real strategy), execution barely decent:
  score=60, verdict=moderate

Difference: 50 points in favor of the real strategy, despite the mediocre execution.

=== Part 3: synthesis report ===

{
  strategyStatementsFound: 2,
  badStrategyStatementsFound: 5,
  worstCase: { score: 10, verdict: 'failing' },
  betterCase: { score: 60, verdict: 'moderate' },
  verdict: 'the real strategy with mediocre execution beats the perfect execution of the wrong sentence'
}

Read the three parts together, because together they tell the project's full story. Part 1's audit confirms, with a hard number, something you probably already suspected if you followed the module closely: only 2 of Mercado's 7 board-deck sentences are a real strategy. The rest — 71% of the deck — is bad strategy in one of its forms: empty aspiration, numeric target, or fluff. That number, on its own, would already be a serious alarm in any real planning meeting. Part 2 turns that alarm into a concrete cost: if Mercado decided, with all its engineering capacity, to flawlessly execute the emptiest sentence in the deck, the result would be a failure (score = 10, verdict = 'failing') — while pursuing the deck's one real choice, even with mediocre execution, produces a result six times better. And Part 3 puts both numbers together, in a single object, ready to bring to the conversation where it actually matters: the one that decides what Mercado builds next quarter.

Common mistakes

Presenting the audit count without the calculated cost. What happens: someone brings Part 1's result to a meeting ("2 of 7 sentences are real strategy") as if the number alone were enough to convince the team to invest time in better defining the strategy. Why it happens: the count feels like the final result, and calculating the additional cost (Part 2) seems like an optional extra step. How to spot it: the typical reaction to "5 of 7 are bad strategy" is a shrug — "well, at least we have 2 good ones" — because the number alone doesn't convey the urgency. How to fix it: the count diagnoses the problem; the cost (Part 2) is what makes it impossible to ignore. The difference between presenting "5 of 7 sentences are vague" and presenting "pursuing the vague sentence with perfect execution leaves us six times worse off than pursuing the real sentence with mediocre execution" is the difference between an observation and an argument.

Assuming the 2 real sentences are already, together, a complete strategy. What happens: seeing that 2 of the 7 sentences pass the test, it's concluded that Mercado's strategy is already settled and no more work is needed. Why it happens: passing isRealStrategy's test (having the shape of a choice with a trade-off) gets confused with having Rumelt's full kernel (diagnosis + guiding policy + coherent actions), which lesson 3 already carefully distinguished. How to spot it: sentences 3 and 5 of the deck declare a choice of segment and of where NOT to compete, but they still say nothing about vision (module 2), formal positioning (module 3), differentiation (module 4), the full competitive landscape (module 5), or the moats that sustain it (module 6). How to fix it: the 2 real sentences are a solid starting point — far better than the other 5 — but they're just the seed of the complete strategy the rest of this guide is going to build, piece by piece, on top of that same direction.

Treating the report's worstCase as a prediction, not a warning. What happens: { score: 10, verdict: 'failing' } gets read as if it were an inevitable prophecy, instead of a warning about what would happen if Mercado made that specific decision. Why it happens: a concrete number, coming out of an executed model, feels more deterministic than it actually is. How to spot it: someone cites the report saying "we're going to fail" instead of "if we pursue the empty sentence, the pedagogical model predicts a poor outcome — let's avoid that direction." How to fix it: remember, as throughout the guide, that outcomeOf is a pedagogical model with illustrative weights, not a validated business formula — its value isn't in predicting the future precisely, but in making tangible, with a number, an argument that would otherwise stay in the realm of opinion: strategy matters more than brilliant, badly-aimed execution.

Exercises

Exercise 1 — Add an eighth sentence. Write a new, eighth sentence for Mercado's board deck, one you believe should classify as strategy. Before running it, predict the verdict and the reason. Then add it to the boardDeck array and verify by running all of Part 1 — did the final count change as you expected?

See solution

A reasonable sentence: "Giving up competing on price with the generic giant, we invest that margin in a local seller verification program." Run through isRealStrategy, it contains the giving up signal, so the expected verdict is strategy, with the reason "declares a choice with an explicit trade-off." Added to the array, the final count would go from 2 of 7 to 3 of 8 — bad strategy is still the majority of the deck, but the proportion improves slightly (from 28.6% to 37.5% real sentences). The point of the exercise is to notice that the model is fully reusable on any new sentence, without changing a line of its code — the generality of the criterion is, precisely, what makes it useful beyond this specific Mercado case.

Exercise 2 — Calculate a third cost scenario. Adapting Part 2, calculate what would happen if Mercado pursued the real sentence ("curation + local sellers") with great execution, instead of medium. Without running the code first, predict the score and verdict, and compare it with Part 2's worstCase.

See solution

outcomeOf({ strategyQuality: 'right', executionQuality: 'great' }) gives score = Math.round(100 * 1.0) = 100, verdict = 'great' (the model's full ceiling, as you saw in lesson 4's exercise 1). Compared with Part 2's worstCase (score: 10), the difference is 90 points — ten times better. This third scenario lays out the full picture, worst to best, with the same real strategy: poor (30, bad execution) → moderate (60, decent execution) → great (100, perfect execution). All three numbers beat the 10 of pursuing the wrong sentence with perfect execution — the most complete possible proof that, in this model, no amount of execution on the wrong strategy even reaches the worst case of the right strategy.

Exercise 3 — Mercado's closing argument. Imagine you have to present the complete Part 3 report at Mercado's next planning meeting, in front of the founder and the VP of Product. Using the report's exact numbers, write the 3-4 sentence argument you'd use to convince them it's worth pausing to complete modules 2 through 7 of this guide before continuing to build.

See solution

One possible argument, backed by the project's real numbers: "We audited the seven sentences that came out of our two planning offsites, and only two pass the test of being a real strategy — the rest are goals, aspirations, or sophisticated language with no real choice behind them. That wouldn't be serious if the cost of leaving it unresolved were low, but it isn't: if we pursue the emptiest sentence in the deck, 'be the leader of the region,' with the best execution we can muster — our whole team, full speed — the pedagogical model we ran predicts a result of barely 10 out of 100. If instead we build on the one real direction we've already identified — curation and local sellers — even with mediocre execution we reach 60, six times better. We're not asking to stop building: we're asking for two weeks to complete the vision, positioning, and moats on the direction we already know is right, before next quarter's engineering effort gets spent, again, chasing one of the five empty sentences." The argument works because it doesn't ask for faith or intuition — it asks for a short pause, backed by an exact number anyone can reproduce by running the same code.

Summary and next step

In this mini-project you audited Mercado's complete board deck, bringing the module's seven lessons together into a single verified workflow: you confirmed only 2 of 7 sentences were a real strategy (Part 1), calculated the concrete cost of pursuing the wrong sentence with perfect execution versus the real one with mediocre execution — a 50-point difference, six times the result — (Part 2), and synthesized both findings into a single report, ready to defend in a real meeting (Part 3).

With this you close module 1. You now have the vocabulary and the central reflex for this entire guide: the difference between tactics and strategy, the criterion for telling a real choice from an empty aspiration, the numeric certainty that execution doesn't rescue a bad choice of game, and the concrete reason why this is also your job as an engineer.

Where you go next. Module 2 takes the one piece of strategy Mercado already has — the curation-and-local-sellers direction that survived this audit — and builds, on top of it, the layer that's missing above it: vision. You're going to learn why a clear vision restricts as much as it enables — it says both NO and YES — and to define Mercado's complete vision with the same rigor you used to audit its board deck here. And further ahead: segment and positioning (module 3), differentiation (module 4), the competitive landscape (module 5), moats (module 6), and the complete strategic filter over the product-thinking backlog (module 7) — up to the module 8 capstone, where you return to Mercado one last time, with the complete strategy built piece by piece and applied, in code, to its real roadmap.

Resources

• Richard Rumelt, Good Strategy Bad Strategy: The Difference and Why It Matters — penguinrandomhouse.com/books/208668. Revisit it once more as you close the module: the original source of the criterion this project just applied in code to the complete board deck. In English.
• Roger L. Martin, Playing to Win: How Strategy Really Works (with A.G. Lafley) — rogerlmartin.com/lets-read/playing-to-win. As a bridge toward module 2: the complete "where to play and how to win" framework you're going to use to build Mercado's real vision and strategy. In English.
• Michael E. Porter, "What Is Strategy?" (Harvard Business Review, 1996) — hbr.org/1996/11/what-is-strategy. Worth rereading now that you've audited a full case: Porter explains why real strategic positioning almost always means giving something up — exactly what separated the 2 real sentences from the 5 empty ones in this project. In English.
• Marty Cagan (Silicon Valley Product Group), "Product Strategy" — svpg.com/product-strategy-overview. The same argument written for software product teams, with real cases of companies that mistook objectives and roadmaps for a real strategy. In English.