Composing the Decentralized Future of Infrastructure

Lego Bricks to compose networks of bits and atoms

Apr 02, 2025

Imagine building an internet-scale application as easily as snapping together Lego bricks: one brick for wireless connectivity, another for storage, another for computing power. This is the vision emerging from Decentralized Physical Infrastructure Networks (DePIN): community-powered networks of hardware (like hotspots, servers, or sensors) that anyone can contribute to and build upon. At the heart of this vision is composability, described by BITKRAFT in Infrastructure & The Future of a Decentralized Web:

Composability is the ability to mix and match software components like lego blocks. The concept is similar to open source, where source code is freely available, but goes a step further in that a system/application can integrate, exchange, and use another system’s functionality and data.

In the context of DePIN, composability means different decentralized infrastructure services can seamlessly plug into each other, allowing developers to mix and match networks like modular components. The result is a more modular, developer-friendly, and integrable foundation for applications, where open networks can be orchestrated through software rather than siloed behind proprietary walls.

In this article, I will explore how composability is becoming the engine of innovation for decentralized infrastructure. We’ll look at examples of networks working together—for instance, how the connected car project DIMO leverages the Helium wireless network—and how shared data and token layers can be reused across applications. I’ll dive into how new software orchestration layers are abstracting away complexity, making DePIN services as easy to integrate as any cloud API. In particular, we’ll highlight Beamable’s approach to building a composable software layer atop DePIN for game development, and compare it with parallel efforts in the wireless, compute, and storage realms. Along the way, we’ll discuss how composability can bridge Web2 and Web3, and examine the powerful network effects that arise when systems are designed to work together.

Let’s start with the big picture vision of composable infrastructure.

The Vision of Composability in DePIN

Composability isn’t a new idea—it’s simply the idea that when software is structured into components that easily build upon each other. The internet itself is an example of a composable network, utilizing the interoperability of TCP/IP, domain names, email, HTML/HTTP and other common protocols that make it easier to deliver applications. It’s the idea that many small pieces loosely joined can enable more power, creativity and connectedness. Indeed, composability is something that predates human software—it’s the foundation of life, as I write about in Composability is the Most Powerful Creative Force in the Universe.

Composability can be internalized or externalized. Internalized composability are cases where there’s a component architecture you can build from, but it requires you to build within a particular proprietary environment. A good example is Salesforce Cloud, where you can access compute resources and build around an interoperability framework based on Salesforce data interfaces. A broader example could include any of the major cloud service providers (AWS, Google, Azure, etc.) and any of their siloed technology solutions (e.g., Playfab on Azure) that operate as lead-gen and vendor-lock-in mechanisms.

The strongest network effects happen with externalized composability, where components, interfaces and the permission-to-create are unshackled from any one centralized provider.

In the realm of blockchain, public ledgers are a natural way to enable a variety of applications because it allows companies who might not trust each other—and could even compete with each other—to cooperate without extending trust. One of the first major wins for blockchain composability is the “financial Lego blocks” within Decentralized Finance (DeFi), where various software modules could snap together to create integrated lending, trading, options, yield management and other yet-undreampt-of financial applications.

Intra vs. Inter-DePIN Composability

Composability for a DePIN project can also be thought of in two additional respects: inter-DePIN composability (where DePIN projects build alongside and atop each other, to create new aggregate as well as intra-DePIN composability (where the DePIN provides a software modularity layer for customizing the functionality of the DePIN itself).

With inter-DePIN composability, one decentralized network’s services can be used by another, or by any application, through standard interfaces. A prime example is DIMO, a user-owned connected vehicle platform, which was able to bootstrap its early network by access Helium for wireless data transfer. DIMO dramatically lowered connectivity costs and barriers for its users. In fact, the DIMO became the first connected car device to use Helium at scale, allowing drivers to get years of connectivity for a one-time $99 fee with no monthly bill, thanks to Helium’s low-cost, community-run infrastructure.

This vision extends beyond just two networks. Imagine a decentralized application that, under the hood, uses Helium for connectivity, Filecoin for storage, and compute network for execution—each a specialized DePIN service. Because these networks expose open interfaces and protocols, a developer can integrate them into a single stack. The data flows and economic incentives can cross boundaries: an IoT app might use Helium for sensor data uplink, store that data on Filecoin’s distributed storage, and perform AI inference on Aethir’s cloud—all orchestrated through software. The token and data layers of these networks become reusable primitives. For example, a device’s data plan might be paid in Helium tokens while data storage is paid in Filecoin’s token, yet from the user’s perspective it’s one seamless service. We already see early glimpses: Helium’s HNT token has been used to incentivize various networks (LoRaWAN, 5G), and projects like WeatherXM (weather sensors) or Hivemapper (mapping with dashcams) similarly plan to leverage Helium’s connectivity. Composability means DePIN networks can talk to each other, share data, and even share incentive models, rather than operate in isolation.

Software orchestration layers are emerging to make this interoperability practical. It’s one thing to have open APIs; it’s another to easily orchestrate multiple decentralized services in a developer-friendly way. We’re beginning to see middleware that acts as the glue—for example, Helium provides a Console where developers route IoT device data from the Helium network into their own databases or cloud services with a few clicks.

If you want to rent some compute power on a decentralized network and pipe the results into a storage network, the software layer should make that as straightforward as using AWS. This is the direction things are headed: different DePIN projects integrating their offerings through common interfaces and orchestration tools, allowing developers to plug in infrastructure like building blocks.

Beamable’s Approach: DePIN + Software for Games

At Beamable we are launching the Beamable Network—essentially a DePIN aimed at game servers and backend software—with composability at the core of our vision. Beamable Network’s protocol will leverage native web3 interfaces to enable inter-DePIN solutions—as well as a software ecosystem that invites traditional backend developers to create live service modules for game studios without any knowledge of blockchain.

Beamable’s approach is to provide a software orchestration layer atop decentralized hardware that is as easy for developers to use as a traditional cloud service. Guy Wuollet at a16z gives a good introduction to how a network such as this is organized to shift power and control—as well as improve economics—for network users:

A Decentralized Physical Infrastructure Network (DePIN) is any sufficiently decentralized network that uses cryptography and mechanism design to ensure a client can request physical services from a set of providers — breaking the natural monopoly and providing the benefits of competition…depending on the network, they can vary from gig workers to massive incumbent corporations. “Decentralization” here means decentralization of power and control, not just of physical distribution or data structure.

In Beamable’s case, the goal is to let game studios provision from a “virtual hyperscaler” that’s aggregated from a range of top-tier, secure data centers with compute resources, databases, and live services—without having to worry about the underlying implementation.

The core Beamable stack includes Unity and Unreal Engine SDKs, developer dashboards, and other tools familiar to game developers. These drive a Web3-powered backend behind the scenes. In fact, games running on the Beamable DePIN will be indistinguishable from a traditional backend-as-a-service offering to the end-user or even the developer.

A game studio integrates Beamable Network with a single line of code and get a fully managed backend. And unlike solutions like PlayFab, the software runs universally on the network—inviting other developers to build their own “gaming lego blocks” that add capabilities to an interoperable network of servers. And because it is built on top of DePIN, which has an inherent blockchain-based settlement layer for provisioning and paying for compute, these novel services can use the same payment ecosystem to earn royalties or license fees.

This is composability turned into an economic ecosystem—independent components snapping together, each adding exponential value to the community as more are added. It’s akin to an open marketplace of game backend features: interoperable, modular, and community-driven.

All of this is made accessible to both Web2 and Web3 game developers. Beamable works for a traditional mobile or PC game (with no crypto elements) just as well as for a fully blockchain-integrated game. In practice, a Web2-oriented developer could use Beamable Network simply to gain cost savings and reliability (since a decentralized network has no single point of failure) for their game’s backend.

On the flip side, if a game does want to incorporate Web3 features (like player-owned assets, NFTs, or on-chain logic), those capabilities are readily available, since Beamable’s infrastructure is Web3-native at the core

This makes Beamable’s platform a bridge between the two worlds: it abstracts away the complexity of blockchain (so Web2 developers don’t need to care about it at all), while exposing the composability and programmability of Web3 (so innovators can leverage it). It’s a strategy to bring cloud-native game developers into the decentralized infrastructure world without forcing them to learn new paradigms all at once.

Composability Across Wireless, Compute, and Storage

Beamable’s vision in gaming parallels what’s happening in other verticals like wireless, cloud compute, and storage – all under the umbrella of DePIN. Each of these sectors has flagship projects building decentralized, physical networks, and now many are layering on software to improve modularity and integration. Let’s look at two of those who came before:

Wireless: Helium

Helium is perhaps the best-known DePIN project, starting with IoT coverage and now expanding into cellular. It proved that community-owned infrastructure can scale: over 900,000 Helium hotspots were deployed globally by individuals, blanketing cities with IoT coverage and now providing pockets of 5G service. What’s notable lately is Helium’s focus on composability with traditional telecom. Through a partnership with T-Mobile, Helium launched an MVNO service called Helium Mobile, where user devices seamlessly roam between the decentralized Helium network and T-Mobile’s nationwide 5G network. A user can buy a $20/month unlimited phone plan and their phone will use Helium’s community-run 5G hotspots when available, or T-Mobile’s towers elsewhere.

The user doesn’t need to know anything about tokens or hotspots; they just get cheaper cell service. This is a powerful example of composability: a decentralized wireless network plugging into a Web2 carrier network, effectively augmenting each other. Helium’s blockchain coordinates the incentives and payments behind the scenes, but from an integration standpoint, it exposes a standard telecom interface. Similarly, Helium’s IoT Console lets enterprise users route device data to AWS or other cloud endpoints easily. By designing its system to support standard integrations and partnerships (like roaming agreements), Helium shows that DePIN infrastructure can slot into real-world applications without friction. A ride-share scooter company, for instance, could use Helium for connectivity in its scooters while using a traditional cloud for its app – mixing decentralized and centralized pieces. This hybrid composability is key to driving adoption in the wireless space.

Storage: Filecoin

In decentralized storage, Filecoin stands out for its scale and integration capabilities. Filecoin’s network of storage miners provides a peer-to-peer version of Amazon S3—essentially cloud storage that is distributed globally and verifiable on-chain. What makes Filecoin interesting from a composability standpoint is how it builds on and plugs into existing systems. It uses the IPFS (InterPlanetary File System) protocol as a core layer, meaning data stored on Filecoin can be accessed through IPFS content IDs by any other app. This has enabled a whole ecosystem of services on top: for instance, web3.storage is a developer-friendly service that lets apps store files on IPFS/Filecoin with a simple API call (no blockchain expertise needed)

Many NFT projects use IPFS via Filecoin to store metadata and assets – so an Ethereum dApp can compose with Filecoin for storage, using IPFS as the bridge. We also see cross-chain composability: e.g., Arweave (another decentralized storage network) is used by some Solana projects to back up data, and Filecoin itself is adding support for smart contracts (the Filecoin Virtual Machine) to enable more direct integration with Ethereum and other chains. In short, decentralized storage networks are positioning themselves as drop-in replacements or complements to traditional storage, accessible through familiar interfaces (HTTP, S3-compatible gateways, etc.). This makes it easy for an application to use decentralized storage alongside centralized components. We can imagine, for example, a video streaming service using a decentralized network like Livepeer for transcoding, Filecoin for storing video chunks, and yet still using a traditional CDN for last-mile delivery – a hybrid of Web3 and Web2 infrastructure working in concert. By exposing standard protocols and focusing on developer tooling, storage DePIN projects ensure they can be plugged into broader application stacks without users even realizing it. (When you watch a video, you wouldn’t know if behind the scenes parts of it came from Filecoin or AWS; if the app is well-designed, it’s invisible.)

Through these examples, a pattern emerges: DePIN projects are evolving from standalone networks into integrated services. They are building the connective tissue (APIs, gateways, partnerships) to slot into the real world of applications and enterprise needs. Composability is both a design principle and a practical necessity – a decentralized network on its own is great, but its impact multiplies when it can be combined with others or embedded into existing systems. By making themselves modular, these networks greatly expand their utility. A decentralized network for weather sensors, for instance, becomes far more valuable if its data can be easily consumed by farming apps, climate models, and insurance platforms. That requires open data standards and interoperability – which is exactly what composability is about.

Bridging Web2 and Web3 via Abstraction

One of the most important aspects of composability in DePIN is how it enables a bridge between the traditional tech world (Web2) and the crypto-powered world (Web3). For years, a major critique of Web3 infrastructure has been that it’s too complex and user-unfriendly for mainstream adoption.

Composability offers a solution: abstract the complexity under familiar interfaces. Let the crypto networks do what they do best (incentivize distributed resources, ensure trustless operations), but present their services to developers and users in a Web2-friendly way. This approach allows Web2 applications to tap into Web3 benefits without burdening end-users with new hassles like wallets or tokens.

We saw a clear example with Helium x T-Mobile’s partnership. Helium could have tried to get everyday mobile users to acquire crypto tokens or run specialized apps to use its 5G network. Instead, by partnering with an established carrier and offering a standard cell phone plan, they hid all the crypto complexity in the background. A user simply connects their phone like normal; the phone/SIM itself figures out whether to use Helium or T-Mobile at any given moment. Helium’s blockchain settlement layer handles accounting between hotspot hosts and the carrier, but the subscriber just sees one service. Users get coverage without needing to know about the workings of the blockchain, just as they don’t need to know how the internet routing works on their phone.

This kind of abstraction is powerful: it invites mass adoption because it doesn’t ask users to change behavior, yet it still leverages decentralized infrastructure behind the scenes.

Beamable’s strategy is very much in line with this philosophy. By making Beamable.com a gateway that feels like a normal cloud dashboard for game services, we ensure that game developers (and by extension, players) don’t need to handle blockchain wallets or tokens to use the network. A game studio can integrate Beamable Network via SDK and manage it through Beamable’s portal.

When the game spins up a new server, those actions are provisioned through an on-chain order book and then orchestrated through off-chain compute resources. Node operators receive token rewards. Developers sees a familiar API call and the player sees a “normal” game, without needing to have any knowledge of the on-chain mechanisms. This abstraction layer not only eliminates the Web3 learning curve, it also allows Web2 and Web3 to meet in the middle. Web2 developers can start using decentralized infra for practical reasons (resilience, cost, access to interoperable software modules) without a philosophical leap; and Web3 infrastructure gains adoption and real-world usage in the process.

At the same time, composability ensures that developers who do want to innovate on the Web3 side have the freedom to do so. Because these systems are open, a developer can dive one layer deeper—for instance, integrating directly with the token or smart contract layer – to create new behaviors.

The bridge role of DePIN is also social and strategic. It is attracting cloud-native technologists into the decentralized space by solving tangible problems (like lowering infrastructure costs or improving coverage) rather than selling purely on ideology. At the same time, it gives crypto-native builders access to a broader market by connecting to legacy systems. In essence, composable infrastructure may be the way to onboard the world into Web3—without the world even knowing it.

When an enterprise can use a decentralized network through a simple API and see real ROI, they’ll adopt it without necessarily trumpeting it as “blockchain”—it will just be seen as a better, more composable cloud. Over time, this could normalize decentralized architecture as a standard part of the internet stack, much like open-source software went from fringe to ubiquitous. The key is that composability abstracts complexity: just as developers use Linux without needing to know every kernel hack, future developers might use global decentralized networks without needing to know cryptographic protocol design. They’ll use it because it’s useful and modular.

Network Effects: Composability as a Force Multiplier

Why is composability such a prized trait? One reason is the network effects it unleashes. When systems are composable, growth tends to be exponential rather than linear, because each new component can enhance or reuse every existing component. We’ve seen this pattern repeatedly in both Web2 and Web3 realms – composability turns products into platforms and users into contributors, driving outsized growth in utility and adoption.

Consider the Unix/Linux ecosystem: The Unix philosophy of small, modular programs that can be combined (via pipes and scripts) led to an explosion of software tools. Each tool made all the other tools more valuable because you could string them together to solve new problems. Why would so many entities invest in a shared project? Because Linux’s open, modular nature meant improvements benefited everyone and could be built upon further. The result has been a compounding effect: the Linux kernel grew from just 10,000 lines of code at inception to nearly 25 million lines today, and it now underpins an overwhelming amount of public cloud and supercomputing worldwide.

In other words, composability helped Linux conquer the infrastructure world by enabling massive parallel innovation and integration. Every new feature or driver in Linux instantly became available to all distributions and users, enabling more use cases, which attracted more contributors, and so on: a positive feedback loop of growth.

Now look at cloud platforms like AWS: Amazon Web Services started by offering basic building blocks (simple storage, compute) with clean APIs, and steadily expanded its catalogue to over 200 services across compute, storage, networking, AI, and more. The genius of AWS’s approach was treating everything as components that work together. Need to build a web app? You can compose EC2 (servers) + S3 (storage) + RDS (database) + CloudFront (CDN) + dozens of other services easily because they’re designed to integrate.

Each new service AWS launched didn’t stand alone; it immediately slotted into this interconnected toolkit. This dramatically lowered the barrier for customers to adopt new capabilities – an AWS customer can try a new service with minimal integration effort since it plugs into their existing cloud environment. The result has been a runaway network effect in the cloud market.

It wasn’t just first-mover advantage; it’s that AWS’s composable model created lock-in through added value. The more AWS services you use together, the more powerful the platform becomes, which attracts more customers and encourages Amazon to roll out even more services. In a sense, AWS turned cloud infrastructure into a giant composable playground, and the pace of innovation is staggering because of it. Cloud architects now think in terms of modules (“I’ll use Lambda for this, DynamoDB for that”) rather than monolithic systems.

Yet developers have also been burned by the fact that Amazon and their newer competitors have sometimes introduced centralized services and later withdrawn them from the market (e.g., Gamesparks)—demonstrating that the market truly needs software that sustains beyond any one cloud vendor.

Back to the world of Web3: decentralized finance was accelerated by a few foundational “Lego blocks” such as stablecoins, exchanges, and lending platforms. This enabled entrepreneurs to build new products by combining them. Need an options protocol? You could leverage the existing decentralized exchanges and stablecoins. Want a new yield strategy? Plug into a lending pool and a liquidity pool. This permissionless innovation meant the network effect wasn’t just users attracting users, but developers attracting more developers, each building on the last. Even network growth in terms of users followed: Ethereum’s user base (e.g. wallets, transactions) surged during the early phase of DeFi’s growth, as the composable apps created more utility together than any could in isolation. While the DeFi boom had its ups and downs, the lasting effect is an ecosystem that continues to innovate quickly – for example, new Layer-2 networks on Ethereum are immediately adopting the same composable DeFi pieces, jumpstarting their own growth by reusing what’s already been built. Composability provides a kind of innovation multiplier: a good idea can be amplified and remixed across the network, leading to far greater aggregate value.

The lesson from these examples is clear: composability multiplies network effects. When pieces can fit together, the system becomes more than the sum of its parts. Each additional node, module, or service increases the value of the overall network in a non-linear way (often approaching a quadratic increase in utility as Metcalfe’s law would suggest for network connections). For decentralized physical infrastructure, this means that as more networks and services become interoperable, the usefulness of the whole decentralized ecosystem will skyrocket. A developer who joins one network effectively joins a federation of networks. A user who buys a device for one decentralized service could potentially access others with the same device or account. Tokens might even interlink (imagine redeeming storage credits for compute credits if networks integrate their economies). We are moving towards a future where many decentralized networks collectively form a kind of distributed “cloud” owned by communities. The stronger the integrations and composability, the more this decentralized cloud can challenge the traditional, siloed tech stacks.

Conclusion: A Modular Path Forward

The trajectory of decentralized physical infrastructure is bending toward greater composability, and that could be what elevates it from niche novelty to a foundational layer of the internet. By making disparate networks modular and easy to integrate, we unlock an unprecedented flexibility in how we build systems. Developers will be able to draw on a global palette of community-run services—networking, storage, compute, sensor data, and beyond – and treat them as interchangeable components in their architectures. This Lego-fication of infrastructure means innovation can happen faster (no need to reinvent what already exists), and resources can be utilized more efficiently across domains. A sensor network can feed a data marketplace; a compute network can crunch that data; a storage network can distribute the results—all coordinated without a central company in charge.

Perhaps most importantly, composability keeps the human element and vision intact: it ensures these decentralized networks remain open ecosystems rather than isolated projects. Just as open-source software created a collaborative fabric that underlies all modern computing, open composable infrastructure could weave a community-owned fabric for the next internet.

Projects like Beamable are demonstrating that you can combine the reliability and ease-of-use of Web2 with the empowerment and permissionless creativity of Web3. A game developer using Beamable’s decentralized backend just sees that it scales, it saves money, and it even unlocks new revenue streams if they contribute to it. But underneath, a revolution in how infrastructure is owned and operated is taking place: ownership is shifting to communities, and value is flowing to those who participate rather than just to Big Tech intermediaries. Composability is the key that makes this model viable, because it lowers the walls and lets many contributors build something bigger together, much like Linux or Ethereum succeeded through collective effort.

As we look forward, we can expect the lines between traditional cloud and decentralized networks to blur. DePIN platforms might become part of the default stack for tech companies (“use Helium for IoT, use Filecoin for backups, etc.”) not because of ideology but because they prove to be competitive on merit. Meanwhile, cloud providers themselves are taking notes from the composability playbook – even Gartner declared “the future of business is composable”, emphasizing modularity and orchestration as guiding principles. In that sense, the decentralized movement is aligning with broader trends in tech toward flexibility and interoperability.

The journey is just beginning. Challenges remain (from technical hurdles in seamless orchestration, to ensuring security and trust across composed systems, to refining token models that encourage long-term participation). But the progress so far—from Helium’s real-world wireless users, to Beamable’s live game services running on a decentralized network—suggests a positive trend. The infrastructure of Web3 is growing from the grassroots, node by node, and now layer by layer of software. If composability continues to guide its development, we may soon find that building on decentralized infrastructure is as natural as building on Linux or AWS. When that day comes, the term Web3 might quietly fade—not because it failed, but because it became an invisible part of how we compose our digital world.

Metavert Meditations

Discussion about this post