Every new protocol goes through the same lifecycle. Invention, early adoption, explosion, standardization, saturation. At each stage, the economics for an independent developer look completely different.

In the early stages, there’s nothing to build on. The protocol exists but the ecosystem doesn’t. Too early means building infrastructure that may never matter.

In the late stages, the platform owners have taken over. Every major company has an official integration. The independent opportunity has closed — or been reduced to niche corners where the big players don’t bother.

In between, there’s a window. The protocol has hit critical mass. The ecosystem is real and growing. But the monetization layer hasn’t standardized yet. The big players haven’t shipped their official versions. The demand exists, but the supply doesn’t.

This is the protocol window.

What Makes a Protocol Window

A protocol window has specific characteristics:

Confirmed adoption. The protocol is being used in production by real developers. Growth is measurable and fast. This isn’t a theoretical standard; it’s something people are actually building with.

Sparse monetization. Many implementations exist, but most are free, experimental, or built for internal use. The pathway from “useful” to “paid” hasn’t been established yet. Users are willing to pay but don’t have good options.

Absent large incumbents. The major SaaS companies haven’t shipped their official versions yet. When they do, they’ll dominate the high-visibility slots — but they haven’t. The namespace is open.

Infrastructure exists. You don’t have to build the plumbing. Marketplaces, billing systems, discovery mechanisms already exist or are being built. You can ship a product, not just a proof of concept.

Why Windows Close

The timeline for a protocol window closing is more predictable than it might seem.

Large companies move slowly on new protocols. There’s organizational inertia, competing priorities, and a reasonable wait-and-see posture. They don’t want to invest in something that won’t reach critical mass. So they wait until critical mass is obvious — which is exactly when the window is open.

Once the signal is clear enough that a big company will ship an official integration, the window is closing. Their official version will have the marketing budget, the brand trust, the enterprise support, and the placement advantage that an indie developer can’t match. The indie advantage — speed, specialization, willingness to serve the niche — becomes less decisive as the official options become usable.

The typical window at this stage of a protocol’s lifecycle is measured in months, not years. Not infinite time to move.

Playing the Window

Independent developers who recognize a protocol window have an advantage over both the too-early builders (no ecosystem yet) and the too-late builders (official versions shipped).

The playbook is straightforward: ship fast, specialize deeply, establish distribution before the incumbents arrive. Your moat isn’t the technology — you can’t out-resource a platform company. Your moat is the customer relationships, the niche reputation, and the depth of integration with specific workflows that the official version won’t bother with.

A protocol window doesn’t require perfect timing. It requires noticing when the window is open and moving before it closes. The developers who win are rarely the ones who invented the protocol. They’re the ones who showed up at the right moment with something useful.

Recognizing that moment is most of the work.