What a strategy IS, and what it is NOT

Description

You already know there's a difference between tactics and strategy. It's time to define the second term with the precision an engineer would define any concept they're going to use for the rest of a project: not with a general intuition, but with a criterion you can apply to a concrete sentence and get a defensible verdict.

The definition this guide adopts, taken from Richard Rumelt, is this: a strategy is a coherent set of choices about where to play and how to win. Look at every word. "Coherent set" rules out a loose wish list where the items don't reinforce each other. "Choices" is the word doing the most work in the sentence: for a choice to be a choice, it has to rule out alternatives — if you're not giving anything up, you haven't chosen anything, you've only listed everything you'd like to have. And "where to play and how to win" is the concrete content of those choices: which segment you serve (and which one you don't), and what makes you win there (and what you give up to achieve it).

With that definition in hand, there are three things that sound like strategy and are not, and they're worth naming one by one because all three constantly show up disguised as real strategy:

• It's not a plan. A plan is a sequence of steps ("first A, then B, then C"). You can have a detailed plan, with dates and owners, for executing the wrong game — Ana's plan to climb Cerro Torre with millimeter precision was an excellent plan, and it changed nothing about the fact that it was the wrong mountain.
• It's not a list of objectives. "Grow GMV 30%, improve NPS, reduce churn" are targets — they say where you'd like to end up. They don't say how, and above all they don't say what you give up to get there. Rumelt calls this, bluntly, confusing the destination with the map.
• It's not an empty inspirational vision. "Be the leading marketplace in the region" sounds like strategy on a slide, with the right typography and maybe a motivational background image. But it chooses nothing: it doesn't say who you serve, who you really compete against, or what you sacrifice. It is, in the vocabulary you'll use for the rest of the module, bad strategy: the term Rumelt gives this, and that lesson 7 will dig into further.

Connection to the module. This lesson builds isRealStrategy, the module's first executed model, and runs it against the exact five sentences from Mercado's offsite you saw in lesson 1, without evaluating them yet. You're going to get, for the first time, a defensible verdict for each one — and this same model will reappear, extended, in lesson 7 and in the lesson 8 project.

An analogy: the new year's resolution

Every January, millions of people resolve "this year I'm going to be successful" or "this year I'm going to take care of my health." It's a sincere sentence, said with the best intentions, and yet it almost never gets kept — not for lack of willpower, but because it isn't a strategy, it's a wish dressed up as a sentence. It doesn't say which days you'll train, what you'll stop eating, what activity you'll sacrifice to make room for the new routine. Compare it with: "I'm going to train Monday through Friday at 6 a.m., and to make that happen I'm giving up staying up late watching shows Sunday through Thursday." The second sentence is uncomfortable to say, because it costs something concrete — the weeknight TV marathon. That discomfort, that named trade-off, is exactly the sign that you stopped wishing and started choosing.

"We're going to be the leading marketplace in the region" is a company's version of "I'm going to be successful": nobody could disagree with the sentence, and that's exactly why it says nothing. It costs nothing to say, because it chooses nothing. A real strategy, on the other hand, always makes someone in the room a little uncomfortable — because there's always a reasonable, defensible alternative being deliberately set aside.

Worked example: isRealStrategy on Mercado's offsite

Let's build a model that classifies any statement into two categories: strategy (a real choice, with an explicit trade-off — it says what it will NOT do, or what it sacrifices) or bad_strategy (a goal or aspiration with no real choice behind it). It's a pedagogical model based on text signals: it looks for phrases like "instead of," "sacrificing," "we are not going to" — markers that something is being deliberately left out — or their absence alongside a numeric target or a vague aspiration. It doesn't understand the statement the way a person would: it structures the criterion, it doesn't replace it, and in lesson 7 you'll see, with a concrete example, where it can be gamed.

// isRealStrategy(statement): classifies a statement as 'strategy' (a choice
// with an explicit trade-off -- what's sacrificed in exchange) or 'bad_strategy'
// (a goal or aspiration with no real choice behind it). Pedagogical model based
// on text signals: it structures the criterion, it doesn't replace judgment.
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: it says what it will NOT do, or what it sacrifices' };
  }
  if (hasVagueAspiration) {
    return { verdict: 'bad_strategy', reason: 'is a vague aspiration ("leading", "world-class") with no concrete choice behind it' };
  }
  if (hasBareGoal) {
    return { verdict: 'bad_strategy', reason: 'is a numeric target (a business goal), not a choice about where to play or how to win' };
  }
  return { verdict: 'bad_strategy', reason: 'declares no identifiable choice or trade-off' };
}

const mercadoOffsite = [
  '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.',
];

console.log('=== isRealStrategy: statements from Mercado\'s latest offsite ===\n');
mercadoOffsite.forEach((s, i) => {
  const r = isRealStrategy(s);
  console.log((i + 1) + '. "' + s + '"');
  console.log('   -> ' + r.verdict + ' (' + r.reason + ')\n');
});

const strategyCount = mercadoOffsite.filter((s) => isRealStrategy(s).verdict === 'strategy').length;
console.log(strategyCount + ' of ' + mercadoOffsite.length + ' statements are a real strategy; the rest are bad strategy.');

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

=== isRealStrategy: statements from Mercado's latest offsite ===

1. "We are going to be the leading marketplace in the region."
   -> bad_strategy (is a vague aspiration ("leading", "world-class") with no concrete choice behind it)

2. "This quarter we are going to grow GMV by 30%."
   -> bad_strategy (is a numeric target (a business goal), not a choice about where to play or how to win)

3. "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."
   -> strategy (declares a choice with an explicit trade-off: it says what it will NOT do, or what it sacrifices)

4. "We want to offer the best shopping experience in the market."
   -> bad_strategy (is a vague aspiration ("leading", "world-class") with no concrete choice behind it)

5. "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."
   -> strategy (declares a choice with an explicit trade-off: it says what it will NOT do, or what it sacrifices)

2 of 5 statements are a real strategy; the rest are bad strategy.

There's the answer to the question left open since lesson 1: only 2 of the offsite's 5 sentences were a real strategy. Sentences 1 and 4 are, in this lesson's vocabulary, the "I'm going to be successful" of New Year's resolutions: nobody could disagree, and that's exactly why they choose nothing. Sentence 2 is a target — a number — not a how. Sentences 3 and 5, on the other hand, pass the test: both name something concrete Mercado gives up (exact-SKU searches, a superior in-house search engine) in exchange for something else (browsing buyers, human curation). Notice that sentences 3 and 5, moreover, reinforce each other — both point in the same direction, toward curated discovery instead of pure search — which is exactly what Rumelt means by a "coherent set of choices": they aren't two loose ideas, they're the same underlying choice, said twice from different angles.

The kernel of a good strategy

Rumelt proposes that every solid strategy has three parts, which he calls the kernel. They're worth knowing, because they give you a more complete check than just "does it have a trade-off?":

1. A diagnosis: an honest read of the situation — what's the real obstacle to overcome. For Mercado: "a generic giant already dominates exact-SKU search; competing there head-on is a fight that can't be won with the resources we have."
2. A guiding policy: the general approach for dealing with that obstacle, without yet dropping down to the detail of actions. For Mercado: "instead of competing on search precision, we compete on curated discovery for buyers who don't know exactly what they're looking for."
3. A set of coherent actions: the concrete steps, coordinated with each other, that put the guiding policy into practice. For Mercado, this is, literally, what modules 2 through 7 of this guide are going to build: the vision, the positioning, the differentiation, the moats, and the filter over the roadmap.

The isRealStrategy model you just ran only checks a simplified version of the second part — whether there's a choice with a trade-off — because that's the part that can be detected with a reasonable text signal. The diagnosis and the coherence of the full set of actions require human judgment, and there's no code shortcut for that — the model helps you quickly filter out sentences that don't even pass the first test, it doesn't replace a full evaluation of the kernel.

Common mistakes

Confusing an objective ("grow 30%") with a strategy (how). What happens: in a planning session, someone states the quarter's target number and the team treats it as if it were, already, the strategy — they jump straight to building without ever defining the "how" or "at the cost of what." Why it happens: a number is easy to communicate, easy to put on a dashboard, and feels concrete — more concrete, even, than a qualitative choice. How to spot it: you saw it executed above — sentence 2 of Mercado's offsite ("grow GMV 30%") is exactly this mistake, flagged by the model as bad_strategy. How to fix it: an objective answers "how much and by when?"; a strategy answers "through what choice, and at what cost?" Both are needed, but they aren't the same document, and confusing them leaves the team with no real guidance on what to build to reach the number.

Writing a "strategy" that's a list of aspirations with no choices or trade-offs. What happens: the strategy document lists several desirable things — "be innovative," "be the best place to shop," "grow sustainably" — without any of them saying what's given up. Why it happens: aspirations are easy to write because nobody can object to them; a real trade-off, on the other hand, always makes someone in the room uncomfortable because they preferred the discarded alternative, and that discomfort gets avoided by default. How to spot it: run each sentence of the document through this lesson's criterion — if none of them names something concrete that's given up, you don't have a strategy, you have a wish list formatted as a slide. How to fix it: for every aspiration in the document, explicitly ask "and what do we give up to achieve this?" If the answer is "nothing, we can have it all," that aspiration still isn't a strategy.

Believing a strategy with an explicit trade-off is automatically guaranteed to be correct. What happens: seeing that a sentence passes the trade-off test ("yes, this is a real choice"), it's assumed that choice is automatically the right one for the business. Why it happens: passing the formal test of "this is a strategy" feels like complete validation. How to spot it: nobody in the room questions whether the chosen trade-off — giving up X in exchange for Y — is actually the best bet, they just celebrate that "we finally have a real strategy." How to fix it: a statement being a strategy (having the right shape: a choice with a trade-off) says nothing about whether it's a good strategy (whether that specific choice is the smartest one for the situation). Rumelt's full kernel — diagnosis, guiding policy, coherent actions — is what evaluates whether the choice is good; isRealStrategy only filters whether it even has the shape of a choice. Lesson 4 is going to show you, with numbers, how much it costs to flawlessly execute even a real choice that turned out to be the wrong one.

Exercises

Exercise 1 — Classify without running the code. Before running anything, classify these three new sentences using isRealStrategy's criterion (explicit trade-off → strategy; vague aspiration or numeric target with no trade-off → bad_strategy):

• (a) "We're going to be a world-class organization in customer experience."
• (b) "Giving up per-unit margin, we're going to subsidize shipping for new sellers during their first quarter."
• (c) "We will increase seller retention by 15 points."

Exercise 2 — Rewrite a bad strategy as a real one. Take sentence 4 from Mercado's offsite ("We want to offer the best shopping experience in the market.") and rewrite it so it passes isRealStrategy's test — it needs an explicit trade-off, not just adding a word from the signal list.

"Instead of optimizing checkout for fast single-SKU purchases,
we optimize the discovery experience -- even if that means
more steps before paying -- because our buyer comes to explore,
not to check something off a list."

Exercise 3 — The full kernel. For sentence 5 of Mercado's offsite ("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"), identify, in your own words, the three parts of Rumelt's kernel: the diagnosis, the guiding policy, and at least one coherent action that would follow from it.

Summary and next step

In this lesson you defined strategy with precision: a coherent set of choices about where to play and how to win — and ruled out three common impostors: a plan, a list of objectives, and an empty aspiration. With isRealStrategy run against Mercado's five offsite sentences, you got a concrete verdict: only 2 of 5 were a real strategy. And you met Rumelt's kernel — diagnosis, guiding policy, coherent actions — as the full check behind the simplified signal the model detects.

Before moving on you should be able to: give this lesson's definition of strategy in one sentence; name the three common impostors (plan, list of objectives, empty aspiration); and apply the explicit-trade-off criterion to any new sentence you come across.

Lesson 4 puts an exact number on the risk Mercado runs if, instead of sentence 3 or 5, it had pursued sentence 1 or 4 with flawless execution. There you'll meet outcomeOf, the module's second model, and you'll see, with data, why flawless execution of the wrong strategy is the most expensive — and most deceptive — way to fail.

Resources

• Richard Rumelt, Good Strategy Bad Strategy: The Difference and Why It Matters — penguinrandomhouse.com/books/208668. The source of the kernel (diagnosis, guiding policy, coherent actions) and of the term "bad strategy" this lesson uses for the first time. In English.
• Roger L. Martin, Playing to Win: How Strategy Really Works (with A.G. Lafley) — rogerlmartin.com/lets-read/playing-to-win. The origin of "where to play and how to win," the pair of questions that defines strategy in this lesson. In English.
• Marty Cagan (Silicon Valley Product Group), "Product Strategy" — svpg.com/product-strategy-overview. Cagan makes, in almost the same words, the same distinction between having objectives and roadmaps versus having a real strategy. In English.