Mapping the competition: beyond the obvious rival

Description

Ask anyone on the Mercado team "who's the competition?" and you'll almost always hear the same name in the first five seconds: the generic megastore, the giant whose logo everyone recognizes. It's a correct answer — and also deeply incomplete. This lesson teaches the module's first discipline: mapping the competition means listing every player competing for the same budget and the same attention, not just the one already in your head before you start thinking.

Connection to the module. The module opened with the 360-degree radar versus the fixed forward stare. This lesson is exactly that first sweep of the radar: we're still on the easiest terrain —direct competitors, the ones selling the same thing, to the same type of buyer— but we insist on finding all of them, not just the biggest. Lesson 3 widens the radar to indirect competitors and substitutes; this lesson first fixes the most basic error of all: falling short even within the most obvious category.

An everyday analogy: the delivery app

You're about to order a pizza and you open the delivery app. Before opening it, if someone asked you "which pizzerias are near your house?", you'd probably name two: the one with the big sign on the main avenue, and maybe that other one you went to once for a birthday. But once the app finishes loading, the list has fourteen options — half of them you'd never have named from memory, and yet each one competes for exactly tonight's order.

That's what almost always happens to a product team when someone asks "who's the competition?" with no process: memory brings up the two or three most visible names —the ones that showed up in a news article, the ones an investor mentioned, the ones with the closest office—, and stops there, not because there aren't more, but because memory stops searching as soon as it finds an answer that "sounds complete." The delivery app doesn't have that problem: it doesn't rely on anyone's memory, it systematically scans everything that exists within the delivery radius. This lesson teaches you to do, with discipline, what the app does automatically.

Worked example: Mercado's direct competitors, complete

If you asked the Mercado team from memory, they'd name a single direct competitor: MegaStoreGenerico, the megastore everyone knows. But a disciplined mapping —checking which other platforms sell the same kind of broad catalog, to the same type of browsing buyer— finds a second player, smaller and less talked about in meetings, but real: SuperTiendaExpress, a regional chain with less brand recognition but an almost equally broad catalog.

We run competitiveMap —the same model from lesson 1— with both direct competitors, not just the most famous one, to see whether the second one changes anything about the landscape:

// Pedagogical model: places each player on a 2x2 map along two
// STRATEGIC axes (not objective market metrics) and flags whether
// "our" quadrant is open -- the space where Mercado can win without
// running head-on into another player.
function competitiveMap(us, players, axes) {
  const [xAxis, yAxis] = axes;
  const place = (player) => {
    const xSide = player.scores[xAxis.key] >= xAxis.midpoint ? xAxis.high : xAxis.low;
    const ySide = player.scores[yAxis.key] >= yAxis.midpoint ? yAxis.high : yAxis.low;
    return `${ySide} / ${xSide}`;
  };
  const usQuadrant = place(us);
  const placed = players.map((p) => ({
    name: p.name,
    type: p.type,
    quadrant: place(p),
    sharesQuadrantWithUs: place(p) === usQuadrant,
  }));
  const openSpace = !placed.some((p) => p.sharesQuadrantWithUs);
  return { us: { name: us.name, quadrant: usQuadrant }, players: placed, openSpace };
}

const axesDiscovery = [
  { key: 'breadth', label: 'catalog breadth', low: 'niche', high: 'broad', midpoint: 5 },
  { key: 'curation', label: 'curation depth', low: 'raw-search', high: 'curated', midpoint: 5 },
];
const us = { name: 'Mercado', scores: { breadth: 8, curation: 8 } };

const players = [
  { name: 'MegaStoreGenerico', type: 'direct', scores: { breadth: 9, curation: 2 } },
  { name: 'SuperTiendaExpress', type: 'direct', scores: { breadth: 6, curation: 3 } },
];

const result = competitiveMap(us, players, axesDiscovery);
console.log('=== competitiveMap: Mercado\'s direct competitors ===\n');
console.table(result.players);
console.log(`openSpace: ${result.openSpace}`);

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

=== competitiveMap: Mercado's direct competitors ===

┌─────────┬──────────────────────┬──────────┬──────────────────────┬──────────────────────┐
│ (index) │         name         │   type   │       quadrant       │ sharesQuadrantWithUs │
├─────────┼──────────────────────┼──────────┼──────────────────────┼──────────────────────┤
│    0    │ 'MegaStoreGenerico'  │ 'direct' │ 'raw-search / broad' │        false         │
│    1    │ 'SuperTiendaExpress' │ 'direct' │ 'raw-search / broad' │        false         │
└─────────┴──────────────────────┴──────────┴──────────────────────┴──────────────────────┘
openSpace: true

The numerical result didn't change —openSpace is still true, Mercado's quadrant is still open—, and that's exactly what makes this mistake so easy to make without immediate punishment: adding the second competitor didn't change today's conclusion. SuperTiendaExpress lands in the same quadrant as MegaStoreGenerico — broad, no curation —, so it doesn't reveal any new threat to Mercado's space. But notice what did change: now you know why the quadrant is open —two independent players, not just one, confirm the same pattern—, and you have a second name on the radar for when either of them decides to move. A mapping that stopped at MegaStoreGenerico would have reached the same conclusion today for the wrong reason: by luck, not discipline. The next time the landscape shifts, that difference matters.

Deep dive: what a mapping process looks like, versus a list from memory

The most reliable way to map the competition without falling short isn't "thinking harder" — it's replacing memory with a systematic source. Three sources that, together, almost always find the second and third player that memory skips:

• The buyer's search, not yours. Write out, literally, the three or four searches a real buyer would run to solve the same job Mercado solves ("buy something I didn't know I wanted", "discover local products") and note every result that shows up, without filtering by whether it "sounds like a real competitor."
• Whoever sells to the same seller. A direct competitor doesn't just compete for the buyer — it also competes for the seller deciding where to list their catalog. Any platform recruiting the same local sellers Mercado wants is, by definition, a direct competitor, even if its brand is unknown to the end buyer.
• The list that's embarrassing to admit you forgot. In almost every competitive mapping exercise done as a team, there's a moment when someone says "oh, right, there's also X" — and that "right, there's also X" almost always arrives late, after the first version of the map has already been presented as complete. Schedule that moment beforehand: ask sales, support, and anyone who talks to customers every day, explicitly, because they hear competitor names the product team never sees in the news.

None of these three sources requires a budget or a specialized tool — they simply require not relying on the list you already had in your head before you started looking.

Common mistakes

Mapping only the obvious direct competitors. What happens: the team builds "the competitive map" from memory of the last meeting, and ends up with one or two names —always the biggest, the best known— presented as if they were the complete landscape. Why it happens: the brain stops searching as soon as it finds an answer that feels sufficient, and the most famous name always reaches memory first, giving the false sense that the search is already done. How to spot it: if your list of direct competitors has a single name, or if no one on the team can explain why that was the only one who showed up, you probably stayed on the surface. How to fix it: apply at least one of this lesson's three systematic sources —the buyer's search, whoever recruits the same seller, or asking whoever talks to customers every day— before considering the list closed.

Confusing "the most famous" with "the most dangerous." What happens: the team spends all of its competitive-analysis energy on the player with the biggest marketing budget, and pays zero attention to the smaller, quieter competitor that's nonetheless growing faster or competing on the exact ground where Mercado staked its differentiation. Why it happens: brand visibility gets confused, with no real evidence, for strategic relevance — it's easier to talk about the competitor in the news than the one almost nobody mentions. How to spot it: ask, for each competitor on your list, "how much would it cost them to copy the part that makes us different?" — a small player already copying that specific part is more dangerous than a big one competing on completely different ground. How to fix it: weight the list not by brand size, but by how close each player is to the exact ground where Mercado chose to play (the same ground from modules 3 and 4).

Declaring the map "complete" and never updating it again. What happens: the mapping is done once, usually at the start of a project or a planning cycle, and then it sits archived as if the landscape were static — nobody revisits it until a new competitor has already caused visible damage. Why it happens: mapping the competition feels like a "one-time" task (like filling out a form), not a continuous process. How to spot it: if you can't say when the last time was that someone added or removed a name from the competitor list, the map is stale, even if nobody's noticed yet. How to fix it: treat the map as a living document with an owner and a review date — lesson 5 of this module explains, in fact, why the landscape shifts even when no new competitor has appeared.

Exercises

Exercise 1 — Find the missing competitor. The Mercado team presents its mapping with a single direct competitor: MegaStoreGenerico. Using this lesson's three systematic sources (the buyer's search, whoever recruits the same seller, asking whoever talks to customers), write one concrete question the team should ask itself to find the second competitor they're missing.

See solution

A reasonable question, applying the "whoever sells to the same seller" source: "Which other platforms are actively recruiting the same local sellers we want on Mercado? If a local seller told us 'such-and-such company also reached out to me,' would we recognize that name?" This question specifically targets finding competitors that compete on the same side of the market (sellers), not just the demand side (buyers) — which is exactly the angle that tends to reveal the lesson's SuperTiendaExpress: a smaller player, without the giant's brand, but real on the ground that matters.

Exercise 2 — Run competitiveMap with a third competitor. Add a hypothetical third direct competitor, TiendaDeDescuentos, with breadth: 7, curation: 1 (broad catalog, almost no curation — competes purely on low price). Predict its quadrant and whether it shares a quadrant with Mercado, then verify by running the code with this third player added to the players array.

See solution

With breadth: 7 (≥ 5, falls into high → 'broad') and curation: 1 (< 5, falls into low → 'raw-search'), TiendaDeDescuentos lands in the 'raw-search / broad' quadrant — the exact same quadrant as MegaStoreGenerico and SuperTiendaExpress. sharesQuadrantWithUs returns false (it doesn't share with Mercado), so openSpace stays true. The pattern reinforces itself: every new direct competitor confirms the same zone —broad, no curation—, and none of them yet invades the quadrant where Mercado competes.

Exercise 3 — Defend the mapping to a skeptic. A manager tells the team: "this is a waste of time, we all know who the competition is, it's MegaStoreGenerico and that's it." Write, in two or three sentences, why finding the second and third direct competitor —even though they don't change today's openSpace result— is still worthwhile work, using this lesson's vocabulary.

See solution

A sample answer: "You're right that today's result doesn't change — Mercado's quadrant is still open whether the list has one direct competitor or three. But the value isn't in today's result, it's in knowing why it's true: with a single name, we don't know if the space is open for a structural reason or by chance. With three independent names landing in the same quadrant, away from ours, we have real evidence of a pattern, not a coincidence. And the day one of those three decides to move toward curation, we'll be the first to notice — precisely because it was already on our radar, not appearing out of nowhere."

Summary and next step

This lesson fixed the most basic error in competitive mapping: stopping at the most famous name and calling the list closed. You saw three systematic sources —the buyer's search, whoever recruits the same seller, and asking whoever talks to customers every day— to find the second direct competitor that memory alone can't find, and you ran competitiveMap with both players to confirm that, even though today's numerical result didn't change, the complete mapping leaves you better prepared than the incomplete one.

Before moving on you should be able to: name at least two systematic sources for finding direct competitors beyond the most obvious one, and explain why a complete mapping matters even when the immediate result doesn't change.

We're still, deliberately, sticking to one type of competitor: the direct one, the one selling the same thing. Lesson 3 breaks that limitation — and that's where the map starts getting interesting.

Resources

• Michael Porter, "The Five Competitive Forces That Shape Strategy" — hbr.org/2008/01/the-five-competitive-forces-that-shape-strategy. Porter insists that a competitive analysis focused only on visible rivals is already incomplete — this lesson's whole framework is, in essence, a disciplined application of that idea to everyday mapping. In English.
• Jeff Jordan (a16z), "So You Want to Compete Against Amazon?" — a16z.com/so-you-want-to-compete-against-amazon. Jordan explicitly names several smaller, less obvious competitor types that manage to take ground from a giant — the same exercise of looking beyond the biggest name that you did in this lesson. In English.