How to build resilient dApps with an agnostic open source deployment layer, or why Web3 isn’t going mainstream because the code that powers it is controlled by greedy middlemen.

Our thesis for why Web3 is broken (and how RAIRprotocol can fix it) involves solving the 3 existential threats to dApp creation and deployment. Namely: API Risk, Source Code Risk, and Cloud Risk.

Problem 1: API Risk

TL:DR: Web3 devs take shortcuts to glue together dApps quickly using VC backed centralized API services

Unlike L1/L2s and other deeper parts of the Web3 stack, the dApp layer is riddled with centralized middlemen trying to sell you black boxes.

Most of these dApp layer services have unsustainable business models. Their headcount is reliant on their ability to fundraise. The math to calculate how long they have left is not hard.

• Headcount x ~10k USD (mix of US and overseas workforce) X 2 for additional OPEX + cloud burn

• Eg. 50 employees = 500k month x 2 or 1m/month. If you raised 24m in 2022 then either raise more by the end of 2024 or go under. Yes they could in theory have revenue to extend indefinitely but c’mon this is web3 - all promise no usage.. yet

This leaves us with a bunch of connections to shoddy APIs that may or may not exist 5 years from now, maybe 5 months from now. Because they don’t tell you how their APIs work, should they fail, you fail.

Problem 2: Source Code Risk

TL:DR: Closed source or not fully open source = systemic vendor risk

An extension of the first problem, let’s dig into the nuance of closed source, vs partially open, vs fully open source.

Totally Closed Source

This is where you call api.vcbackedservice.com and receive back some kind of useful data. Could be RPC data, or price feeds, etc. This could also be fully fledged WYSIWYG Squarespace like Web3 services. Behind the scenes there is no Github, just a pure black box.

Caveat:* Squarespace is a great Web2 company. People don’t usually worry about their website poof disappearing because Squarespace makes money and has a good survivability bias from being in business for so long.*

With Web3 there could in theory be onchain revenue to back the survivability of these closed services - but again - they get paid as a fiat SaaS black box so there is no way to really know..

Examples: Vottun, Magic, Bonfire.xyz

Open Front/Closed Back

AKA party in the frontend, closed in the backend

These are open SDK services with easy frontend tooling to help devs deploy their dApps faster.

Example: Ethers.js is hard to use natively. (tl;dr ether.js is the core Javascript library that powers the entire Eth ecosystem) So instead of using the hard native thing, companies exist to provide simple SDKs that call their centralized service instead.

On the surface, such solutions seem totally open source.

1. There is a Github with tons of activity✅

2. Wait.. to get started navigate to a centralized server to generate a centralized DRM secret key to use all of their amazing tools?

3. Then input said API secret into your dApp or it won’t compile?

Has anyone ever considered what happens if said service ever ceases to exist? How would a dApp go about switching out one provider for the next? Is it even possible to change an engine on your dApp airplane mid flight without crashing..

Examples: Every dApp infra layer company in Web3

Problem 3: Cloud Risk

So you’ve glued together a bunch of centralized VC backed APIs to build your dApp - now what?

Where are you going to run said dApp? The big three GCP, Azure, AWS?

• What if they don’t like you and turn you off?

• What if they charge such extortionate rates to cover their H100 buying spree you’ll go bankrupt paying your cloud bills?

• Where are the Terraform scripts and other devops tooling to help you migrate from one cloud to the next?

Cloud isn’t just an abstracted box that computes your 1s and 0s for you in a server farm somewhere. Cloud is the infinite complexity of kubernetes, nginx, fancy routing, vault key stores, and 1000s of other things no normal person should ever know about.

If this information isn’t also open, then what chance does a dApp hope to stay alive (and scale) in the absence of these easy-to-use black boxes?

Enterprises Aren’t Dumb

Why can’t you click a button inside your Disney+ app and mint a collectible? Or use Etrade for defi and collect yield on 100x leveraged degens?

Because massive corporations will build a toy quickly on a closed system, but will not bet the farm on a small closed source vendor. Rolling out reliable enterprise grade code is really hard, made even harder with black box greed machines gumming up the dApp layer.

Also size matters. Once a service reaches too big to fail status, then sure relying on their closed backend becomes an easier business decision. But who in Web3 has achieved such a scale? Which RPC provider is Disney going to trust to sync 10m transactions a day?

--

Instead of complaining for an entire article, why don’t we go about solving this mess in a sustainable open source way.

Solution: Agnostic Docker Deployment Layer

How can we possibly solve for these 3 huge problems: API risk, Source risk, and Cloud risk all in one fell swoop?

DOCKER BABY!

What is Docker? A centralized container building software that secretly powers the entire internet (but hey at least it’s publicly traded)

How does Docker solve for all 3 huge risks? It allows dApp developers to abstract away an individual provider failure with an open architecture.

Put another way - with Docker you can replace preset variables in a configuration file and easily move from one provider to the next by deploying your “container” or virtual little computer that has all of your code self-contained inside.

To modify these Docker containers you can easily swap out API keys from one vendor to the next, then deploy to any new cloud virtual machine you want.

It’s a riddle, think about Docker for a minute and you’ll get why it’s so powerful.

RAIRprotocol

Docker by itself doesn’t natively solve Web3’s biggest problem. A dedicated team of Web3 devs grinding everyday for 4 years to create an open deployment layer has.

RAIRprotocol is not just an open frontend with a closed backend like everyone else, we show exactly how to build the entire dApp stack in a 100% open and transparent way.

How RAIRprotocol works..

1. Deploy our own self sovereign infrastructure on any cloud you want

Checkout Contabo for the lowest cost cloud VMs, or Akash Network’s upcoming VM product where you can pay with tokens for a censorship resistant cloud.

With a single docker command, you run don’t only an amazing Frontend, Syncing, and Streaming engine as independent microservices - but you also get RAIR-node- our entire backend you can deploy 100% yourself.

api.rair.market goes down - no problem spin up api.yourcooldapp.xyz

2. Switch out your own API keys: AKA the Self-Sovereign part

Note how our Docker file compares to a popular open frontend/closed backend solution..

• You can see the closed backend solution requires their own centralized API secret key to work.

• You can also see how the closed solution is pushing you into their RPC, their wallet service etc.

Their game theory only works in a zero sum way. 100% of “their” developers running on “their” RPC, Wallet infra, etc.

vs RAIRprotocol..

• RPC: Could be Alchemy, or Moralis, or Infura, or Thirdweb, or use our universal syncing engine and go direct to any RPC instead of using a provider.

• Wallet: Same goes. Use non-custodial Metamask or Coinbase Wallet. Or Use Alchemy, Web3Auth, etc AA (account abstraction) provider.

• What about a Zoom integration to unlock token gated meetings?

• Or a Yoti integration to require AI face scan age verification? Also 100% your own keys your own source code.

These services (Zoom, Alchemy, etc) individually are on the same black box model (and that’s totally fine!) Gluing them together with an open source deployment layer puts the power back into the hands of the people. If one sucks, switch them out. At scale, this creates real accountability.

3. Join the Revolution

The ultimate advantage of fully open source vs closed or partial source is in the survivability of an open community. As long as someone cares, the project lives on.

Moreover, large enterprises LOVE open source. If they can see how the system really works, they can modify it internally, and maintain it into the future thus removing a huge IT risk burden. This is how big girl and big boy IT works. See Redhat.

The larger the development community (incentivized by tokens though this is for another article) the bigger the library grows and the more resilient the deployment layer becomes.

learn more @

• X: https://x.com/rairprotocol

• Github: https://github.com/rairprotocol

• Docs: https://docs.rairprotocol.org

--

Thank you for reading all the way to the end and yes we did say black box 6 times in 1500 words

🔥