The self-sustaining flame
The fundamental problem for ecosystems
Certain products and services have the network effect — the property that the more people using them, the better they get for everyone. A related concept is that of a platform: where the more developers there are building things, the more users are attracted, which in turn attracts more developers, in a self-reinforcing spiral. Most of my experience is in the context of the web platform, but similar patterns occur for other developer platforms and even for some classes of user-focused products. Generally these spiralling dynamics are evidence of an underlying ecosystem.
A healthy ecosystem is a roaring bonfire. Once it gets going, it keeps growing on its own with self-sustaining momentum. That’s the wondrous property of a healthy ecosystem: it can produce benefits way greater than the investment put in by its creator.
If you have an ecosystem underlying your product or service, getting that self-sustaining flame is likely your fundamental problem. Without that thriving ecosystem, your product is probably worthless.
Say you want to build one of these bonfires. You study the space you’ve chosen for the fire, plan for how big you want it to be, and place the perfectly sized logs in the perfectly balanced pile. In the real world these logs are things like the engineering resources to design and build the services, features, and infrastructure to support the ecosystem.
But now you need to get these logs started because they’re not just going to spontaneously combust. One way to do that is to use a flamethrower — a perfectly reasonable option if you happen to have one lying around. In practice this might mean having a big launch event supported by a lot of marketing, partnerships, and PR.
Flamethrowers have one big problem. While you’re using them, it’s tempting to see all of that flame and think, “Look at all of that fire! My ecosystem is thriving!” But at some point you will run out of fuel and have to turn off the flamethrower. If none of the logs caught on fire — if you haven’t created the self-sustaining flame — then you’ve failed. And it’s basically impossible to tell if the wood caught without turning off the flamethrower.
If it’s so important to get it right, then what’s the best recipe for a bonfire? What kind of wood should you use? How should you stack it? How high should you build it? It’s impossible to say, because every bonfire is different. In some cases the wind might be the most important factor. In other cases the wood might be too damp. Perhaps you needed more fuel than you thought. In a real-world example you might find that, based on the dynamics of your particular platform in practice, the value developers receive per user is dwarfed by the cost of acquiring that user. In general it is impossible to predict a priori whether or not your bonfire will catch; the forces, although sometimes obvious in retrospect, are too subtle and interrelated to untangle ahead of time.
So is it hopeless? No. The problem was that you were starting with the wood, not the all-important flame. The solution, of course, is to flip that around. Strike a match. You’ve got that self-sustaining flame from the get-go, albeit a bit small. Now grow it. Place it in a ball of straw. When the time is right, add some small dry kindling. Watch if it’s catching: perhaps the wind is blowing and you need start over in a more protected position. At every point look for the next step that will provide the fire with more fuel, being careful not to suffocate it. You might not end up with precisely the type of bonfire you intended when you set out, but what’s more important is that you’ve built the all-important self-sustaining flame.
In practice what this looks like for, say, a developer library is this. Develop the whole thing in the open, from the very first commit. Every meaningful discussion, every difficult decision, every embarrassing setback, should be played out in public. Start out fully obscure: no logos, no brand names, no fanfare. Over time, informally share the link with folks you think might be interested. When others start contributing — on the mailing list, in issue discussions, in pull requests — make them feel welcome and incorporate their input. If you’re on to something, you’ll start seeing evidence of that flame, however small at first. People will start tweeting about it. More people will come and take part in the community. Some people will use it to build real things — first little toys, and then perhaps for services with real users. When this momentum starts to take hold, you’ve found your self-sustaining flame. Now you can focus on nurturing it and growing it by increasing your investment, carefully piling on the kindling, and then the logs.
This technique isn’t bold or glamorous, but it is reliable. In the short term, the guy with the flamethrower will appear to be winning — but in the long term everyone will be huddled around your self-sustaining bonfire for warmth.
