Module 6: Moats And Defensibility

Network effects: the phone that's worth more the more people have one

Next →

Description

A network effect happens when every new user makes the product more valuable for the users who were already there — not as a nice side effect, but as the central mechanism of why the product works. It's not the same as "having lots of users." A news site with ten million readers can be a great business, but if reader number 3's experience doesn't improve at all because reader number 4 signed up, there's no network effect there — there's simply a large audience. The question that separates one thing from the other, and that this lesson installs precisely: does the new user make the product better for everyone else, or does it just add to the active-users count?

This lesson opens the first of the five moat types moatScore recognizes, the one you already saw scored twice —in module 1 and in lesson 2— without the internal mechanics of sides and localDecay being explained yet. You'll leave here knowing how to distinguish a direct network effect from an indirect one, why they reinforce themselves once they get going, and why that same force that makes them almost impossible to copy is what makes them brutally hard to start.

Connection to the module. Lesson 2 showed sellerNetwork with durability: 8 without opening the box on why sides: 2 and localDecay: false produced exactly that number. This lesson opens that box, and adds a third question lesson 2 didn't touch: what happens when the same type of advantage fragments geographically? Lesson 4 does the same with switchingCost, and lesson 5 with dataMoat and scaleEconomies — each type gets its own lesson, one by one.

An everyday analogy: the phone that's useless if you're the only one who has one

Imagine you're the first person in the world with a telephone. You paid a lot for it, it works perfectly, the signal is excellent — and it's completely useless, because there's nobody to call. The day your neighbor buys the world's second telephone, your phone, which didn't change at all technically, suddenly becomes worth something: now you can call one person. The day a hundred more people in your city have one, that same phone of yours —again, with no technical change at all— is worth vastly more than the day before. Nobody improved the device. What changed was how many other people have one, and that's exactly the definition of a network effect: the value doesn't live in the product, it lives in the network of people who use it.

Now notice the other side of the same coin, the uncomfortable one: if your phone's value depends on others having one, then the world's first phone is worthless by definition — not because it's badly designed, but because the network that would give it value doesn't exist yet. That's the cold-start problem: the same property that makes a network effect, once built, nearly impossible to copy —a competitor can't buy overnight the millions of people already in your network— is what makes building it from zero, in the early days, feel like selling phones to nobody.

Worked example: three networks, the same question about sides and localDecay

We reuse moatScore without any changes — the same complete model from lesson 2 — and run it on three of Mercado's different network advantages, chosen to separate two questions that are easy to confuse: how many sides attract each other, and whether that effect breaks when crossing a geographic border.

The first, sellerNetworkNational, is the seller network as you know it: every new buyer makes it more worthwhile for a new seller to join (more people to sell to), and every new seller makes it more worthwhile for a new buyer to stay (more selection, better prices from competition among sellers) — two sides, sides: 2, and the effect accumulates the same regardless of which city in the country each user is in, localDecay: false. The second, sellerNetworkPerCity, has the same two-sided mechanics, but with a structural flaw: if Mercado's algorithm only matches buyers with sellers from their own city, then launching in a new city means starting that network from scratch there, with none of the millions of existing users in the rest of the country helping at all — sides: 2, but localDecay: true. The third, sellerOnlyLoyaltyProgram, is a badge program among sellers —they share tips, refer customers to each other— that improves other sellers' experience when a new seller joins, but has no side that attracts buyers back: a single side, sides: 1.

// Pedagogical model: scores the DURABILITY (0-10) of a competitive advantage.
// Reused unchanged from lesson 2 -- this lesson does NOT modify
// moatScore, it just digs into the parameters of type: 'networkEffect'.
function moatScore(advantage) {
  const { name, type } = advantage;
  let durability;
  let rationale;

  switch (type) {
    case 'networkEffect': {
      const { sides, localDecay } = advantage;
      durability = sides >= 2 ? 8 : 5;
      if (localDecay) durability -= 3;
      rationale = `network effect ${sides}-sided${localDecay ? ', with local decay' : ', no decay'}`;
      break;
    }
    case 'switchingCost': {
      const { depth } = advantage;
      const depthScore = { contractual: 3, habit: 5, dataAndWorkflow: 8 };
      durability = depthScore[depth] ?? 3;
      rationale = `switching cost of depth '${depth}'`;
      break;
    }
    case 'scaleEconomies': {
      const { fixedCostShare } = advantage;
      durability = Math.round(fixedCostShare * 10);
      rationale = `economies of scale with ${Math.round(fixedCostShare * 100)}% fixed cost`;
      break;
    }
    case 'dataMoat': {
      const { feedbackLoop, uniqueToUs } = advantage;
      durability = feedbackLoop ? 7 : 2;
      if (feedbackLoop && uniqueToUs) durability += 2;
      rationale = feedbackLoop
        ? `the data feeds a loop that improves the product${uniqueToUs ? ' and is exclusive' : ''}`
        : 'the data accumulates but doesn\'t feed back into the product';
      break;
    }
    case 'brand': {
      const { pricingPower } = advantage;
      durability = pricingPower ? 6 : 2;
      rationale = pricingPower
        ? 'the brand changes purchase behavior (tolerates price or friction)'
        : 'the brand is recognized but doesn\'t change purchase behavior';
      break;
    }
    case 'feature': {
      const { timeToCopyWeekends } = advantage;
      durability = Math.max(0, Math.min(3, timeToCopyWeekends));
      rationale = `feature copyable in ~${timeToCopyWeekends} weekend(s)`;
      break;
    }
    default: {
      durability = 0;
      rationale = 'unknown advantage type';
    }
  }

  durability = Math.max(0, Math.min(10, durability));
  const verdict = durability >= 7 ? 'moat' : durability >= 4 ? 'weak-moat' : 'not-a-moat';
  return { name, type, durability, verdict, rationale };
}

const candidates = [
  { name: 'sellerNetworkNational', type: 'networkEffect', sides: 2, localDecay: false },
  { name: 'sellerNetworkPerCity', type: 'networkEffect', sides: 2, localDecay: true },
  { name: 'sellerOnlyLoyaltyProgram', type: 'networkEffect', sides: 1, localDecay: false },
];

console.log('=== Three networks, same question: does the effect survive if Mercado gets distracted for a quarter? ===\n');
console.table(candidates.map(moatScore));

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

=== Three networks, same question: does the effect survive if Mercado gets distracted for a quarter? ===

┌─────────┬────────────────────────────┬─────────────────┬────────────┬─────────────┬───────────────────────────────────────────┐
│ (index) │            name            │      type       │ durability │   verdict   │                 rationale                 │
├─────────┼────────────────────────────┼─────────────────┼────────────┼─────────────┼───────────────────────────────────────────┤
│    0    │  'sellerNetworkNational'   │ 'networkEffect' │     8      │   'moat'    │    'network effect 2-sided, no decay'     │
│    1    │   'sellerNetworkPerCity'   │ 'networkEffect' │     5      │ 'weak-moat' │ 'network effect 2-sided, with local decay'│
│    2    │ 'sellerOnlyLoyaltyProgram' │ 'networkEffect' │     5      │ 'weak-moat' │    'network effect 1-sided, no decay'     │
└─────────┴────────────────────────────┴─────────────────┴────────────┴─────────────┴───────────────────────────────────────────┘

Look at the result carefully, because the tie between row 1 and row 2 isn't a coincidence — it's the lesson's central point, written into the formula. sellerNetworkPerCity starts with the same potential as sellerNetworkNational — two sides, buyers and sellers attracting each other —, but the localDecay subtracts exactly 3 points, and it ends up at the same durability: 5 as sellerOnlyLoyaltyProgram, a network that never had a second side to begin with. The takeaway is uncomfortable but precise: a two-sided network effect that breaks at every geographic border is worth, in practice, the same as a network effect that was never two-sided. It's not "almost as good as" the national one — it's, in terms of durability, a different and weaker type of advantage, even though both sides technically exist on paper.

Deep dive: the same force that makes it hard to copy makes it hard to start

Network effects have a paradox worth naming out loud, because it explains why so many products with a genuinely good network idea die before the effect kicks in. The sides formula distinguishes two forms of compounding: the direct one (or single-sided), where the same type of user benefits from more users of their own type joining —think of a contact list: every friend of yours who joins the same messaging app benefits you directly—, and the indirect one (or cross-sided, two or more sides), where one type of user benefits from the other type joining — Mercado's case: buyers don't benefit directly from more buyers, they benefit from more sellers, and vice versa. Indirect effects tend to be the strongest —that's why sides >= 2 starts from a base of 8, not 5— but they're also the hardest to start, because you need both sides at once: a marketplace with lots of buyers and few sellers is useless to everyone, and one with lots of sellers and few buyers is too.

That difficulty of starting isn't a flaw in the model — it's the exact flip side of durability. A well-funded competitor can buy traffic, hire the best engineering team, copy every screen of your product in a weekend (lesson 6's topic) — but it can't buy, overnight, the fact that your same sellers already trust your platform and your same buyers already have it installed. Every new competitor has to solve its own cold start from scratch, no matter how much capital it has, because money buys users, not the cross-sided value network those users already built with each other on the existing platform. That's, at bottom, the structural reason why networkEffect can reach durability: 8 while feature has a ceiling of 3: it's not that a network effect is "harder to code" — it's that not even money, on its own, buys it.

This lesson's localDecay adds a second, subtler trap than the initial cold start: a product can solve cold start once, at the national level, and still keep facing local cold starts every time it enters a new market — if, as with sellerNetworkPerCity, the product's architecture doesn't let the value of the already-built network transfer to the new city. In that case, Mercado doesn't have one strong network effect — it actually has hundreds of small, fragile network effects, one per city, each with its own cold-start problem, disguised as a single big moat in the quarterly report.

Common mistakes

Confusing "lots of users" with a network effect. What happens: someone looks at a large active-users metric and concludes "we have a network effect" without checking whether a new user actually improves everyone else's experience. Why it happens: scale and network effect tend to show up together in successful businesses, and it's easy to confuse correlation with mechanism — a product can have millions of users from a good marketing funnel, with none of them benefiting from the others being there. How to spot it: ask "if half our users left tomorrow, would the other 50%'s experience get worse, or stay exactly the same?" — if the answer is "it'd stay the same," there's no network effect, even if the user count is huge (there might be a real economy of scale, lesson 5's topic, but that's a different mechanism). How to fix it: require any network-effect claim to point to the exact cross-sided mechanism —who attracts whom, and through which channel?— before assigning it type: 'networkEffect' in the model.

Ignoring cold start until it already hurts. What happens: the team designs a new city's launch strategy by copying exactly what worked nationally, and is surprised when growth in the new city is slow in the first weeks, interpreting it as a sign that "the product doesn't resonate there." Why it happens: it's easy to forget, looking at the already-mature, strong national network, that every new segment —geographic, category, user type— starts from the same zero point the whole product once started from. How to spot it: if the conversation about a new city uses the same success metrics as the mature national network, without adjusting expectations for local network size, this step is missing. How to fix it: treat every segment with real localDecay as its own cold start — with its own bootstrapping strategy (subsidize one side first, give single-player value while the other side grows), not as a smaller version of the already-mature product.

Treating the national network effect as if it automatically covers every expansion. What happens: the team assumes that, because Mercado "already has" a strong network effect at the country level, any new category or city automatically inherits that strength, without checking whether the matching architecture actually connects that expansion to the existing network. Why it happens: durability: 8 in the quarterly report feels like a permanent property of the product, not the result of a specific architecture that may or may not apply to the new segment. How to spot it: for every expansion, explicitly ask whether localDecay would be true or false — that is, whether the recommendation, search, or matching algorithm actually crosses the new segment with the existing base, or isolates it. How to fix it: run moatScore separately for each segment with real connectivity data, instead of assuming the national durability: 8 copies and pastes.

Exercises

Exercise 1 — Network effect, or just an audience? A colleague says: "our recipe app has 2 million active users, so we have a strong network effect." Using this lesson's test, does that claim, on its own, describe a network effect? If the app also let users comment on and rate each other's recipes, would that change your answer? Justify both cases.

See solution

No, "2 million users" on its own doesn't describe a network effect — it describes a large audience, which could be the result of a good product or good marketing, with no new user improving anyone else's experience. This lesson's test confirms it: if half of those 2 million left tomorrow, would the cooking experience with the existing recipes get worse for the other million? No — every recipe still works exactly as well no matter how many other users exist. If the comment-and-rate feature is added, the answer changes: now a new user who leaves a helpful review improves the decision of every other user who sees that recipe afterward — that is a network-effect mechanism (probably sides: 1, because all users are the same type, contributing and consuming the same type of value among themselves).

Exercise 2 — Predict before running it. Without running code, using this lesson's networkEffect formula (durability = sides >= 2 ? 8 : 5; if (localDecay) durability -= 3;), predict the durability and verdict of this advantage: { name: 'crossCityBuyerReviews', type: 'networkEffect', sides: 2, localDecay: true } if the model also applied a second localDecay (for example, decay both geographic and by product category) subtracting another 3 points. Verify by running a modified version of moatScore.

See solution

With a single localDecay: true: sides: 2 gives a base of 8, minus 3 for the decay, durability = 5, verdict: 'weak-moat' — the same result as sellerNetworkPerCity in the worked example. If a second decay of another 3 points were applied (a modified version of the formula that adds two penalties), durability = 8 - 3 - 3 = 2, and 2 < 4 gives verdict: 'not-a-moat'. The point of the exercise: decays accumulate, they're not limited to one — a network effect that fragments by city AND by product category at the same time can end up, in practice, with no real strength, even though on paper it's still "a two-sided network effect."

Exercise 3 — Design the cold start. Mercado wants to launch in a new city where it has neither buyers nor sellers yet. Propose, in two or three sentences, a concrete cold-start tactic (for example, subsidize one side first, provide single-player value while the other side grows, or import supply from another source). Then explain which moatScore parameter —sides or localDecay— you'd expect to change, and in which direction, six months after the tactic works.

See solution

There's no single correct answer. A reasonable tactic: Mercado could start by actively recruiting an initial group of local sellers with incentives (reduced commission for the first months), and while that side grows, show buyers in that city the full national catalog with shipping available, so the platform has value even before a mature local network exists — solving the "buyers with nothing to see" problem without yet depending on the local seller side. The parameter you'd expect to change isn't sides (it stays at 2, local buyers and sellers will keep attracting each other) — it's localDecay, which should go from true to false as local matching matures and the city stops depending on importing supply from other regions, bringing its durability closer to the national network effect's.

Summary and next step

In this lesson you opened the first of the five moat types: the network effect, where the value doesn't live in the product but in the network of people who use it. You saw the difference between direct effects (same type of user) and indirect ones (two sides attracting each other, Mercado's case), why indirect ones start from a higher base in moatScore, and why localDecay can reduce a strong national network effect to the same durability level as one that never had a second side. You also saw the type's central paradox: the same force that makes a network effect nearly impossible to copy is what makes starting it from zero feel, at first, like having no product at all.

Before moving on you should be able to: distinguish a real network effect from a large audience, explain the difference between direct and indirect effects in your own words, and calculate by hand the effect of sides and localDecay on durability without running the code.

Lesson 4 opens the second type: switching costs — not what it costs to arrive at a product, but what it costs, in time, data, or habit, to leave it.

Resources

  • NfX, The Network Effects Bible — nfx.com/post/network-effects-bible. The most complete reference on network effects in product strategy: it covers the different types, the mechanics of nodes and network density, and dedicates a whole section to the cold-start problem this lesson introduced. In English.
  • Hamilton Helmer, 7 Powers: The Foundations of Business Strategy — 7powers.com. "Network economies" is one of the book's seven sources of power — the same compounding mechanism moatScore models as networkEffect, with the same emphasis on the advantage growing on its own once it gets going. In English.
← PreviousWhat a moat is (and what it isn't)Next →Switching costs: what it costs to leave, not what it costs to stay