Autoscaling RPC Nodes: The Complete Guide
Autoscaling RPC node solutions dynamically adjust the number of RPC nodes your platform uses based on demand.
In this article, we’ll discuss:
How developers access RPC nodes: Build or buy
How autoscaling RPC nodes work
Autoscaling RPC nodes in action: $MODE airdrop
If you’re building an onchain app, then your network will need to exchange data with Ethereum. Similarly, if you’re building a rollup, your chain will need to exchange data not just with Ethereum, but also with the apps you and other developers maintain on top of your chain. That’s where RPC nodes (remote procedure call nodes) come in. Think of them as the communication line between your platform and the blockchain, enabling you to send transactions, data queries, smart contract execution instructions, and more.
However, your RPC needs will change based on demand for your service. As your user base grows, or if your platform sees spikes in activity, your RPC node performance will dip. That can cause mission-critical problems like failed transactions or data retrieval issues. Luckily, providers like Conduit offer autoscaling RPC nodes. Autoscaling RPC node solutions dynamically adjust the number of RPC nodes your platform uses based on demand, so that you can maintain performance during periods of high traffic but only pay for the nodes you need.
Keep reading, and we’ll tell you everything you need to know about what autoscaling RPC nodes are and how builders can use them, along with a real world example of how autoscaling RPC nodes handle activity spikes during big onchain events like airdrops.
What is an RPC node?
An RPC node is a server that can execute RPCs initiated by onchain apps and rollups, allowing those platforms to communicate with the blockchain. RPCs enable core onchain operations like sending transactions, querying data like user balances, and interacting with smart contracts, so RPC nodes are a must-have for anything built on blockchains. As we’ll explore more below, rollups specifically rely not just on RPC nodes built on Ethereum, but also on RPC nodes built on their own chain.
How RPC nodes work: Core components and the RPC process
RPC nodes run a client software, such as Geth for Ethereum, that allows the node to stay synchronized with the Ethereum blockchain, maintain a copy of the blockchain ledger, and validate transactions.
Each node has an RPC endpoint, which is the URL where applications send requests to the node. Public RPC endpoints are available to anyone, but are generally rate-limited and not designed to accommodate the volume of RPCs onchain apps and rollups need. Instead, those platforms generally use private RPC endpoints, which are designed specifically for their commercial use case. Conduit, for example, provides developers private RPC endpoints for nodes on Conduit rollups specifically.
Onchain apps and rollups initiate RPCs by sending requests to an RPC node’s endpoint using JSON-RPC, the API standard used for RPCs by most blockchains. The node then processes the request and returns the result — e.g. the requested data or result of the requested transaction or smart contract function — to the app or rollup, which then displays it to the end user.
Example of a JSON-RPC request and response:
The code snippet below shows a JSON-RPC request for querying the balance of a specific Ethereum address.
{
"jsonrpc": "2.0",
"method": "eth_getBalance",
"params": ["0x742d35Cc6634C0532925a3b844Bc454e4438f44e", "latest"],
"id": 1
}JSON-RPC response:
{
"jsonrpc": "2.0",
"id": 1,
"result": "0x0234c8a3397aab58"
}The result is the balance of the given address in the latest block in hex format in Wei, the smallest unit of Ether.
RPC node use case examples
Onchain apps, infrastructure, and rollups use RPCs to fulfill numerous core functions on behalf of their users.
For example, an onchain app would use RPCs to:
- Execute a transaction on Ethereum
- Retrieve a user’s wallet balance or transaction history
- Call a smart contract function, such as executing a token swap via a DEX liquidity pool
Many onchain infrastructure components and services use RPCs as well. For example:
- Indexers rely on RPC nodes to query blockchain data
- Block explorers use RPC nodes to track transaction activity by address
- NFT trading infrastructure use RPC nodes to fetch and display NFT metadata
A rollup might use RPC nodes on the chain it’s built on to:
- Post batches of transactions to Ethereum or the L2 it’s built on
- Publish state commitments on Ethereum or the L2 it’s built on
- Submit fraud proofs to settle a dispute over the rollup’s state
Rollups also need reliable RPC nodes on their own chain to maintain apps they run on their chain, and to allow other developers to do so as well. That’s why we consider Conduit Nodes a key part of our platform for rollup teams.
How developers access RPC nodes: Build or buy
Anyone can run their own RPC node by installing and configuring node client software on a machine capable of running it 24/7. However, many onchain builders opt to use third-party providers for RPC nodes in order to save time and focus their efforts on building for their users. Let’s look at the pros and cons running your own node versus working with a node provider like Conduit.
Pros of running your own RPC nodes:
- Customization. Running your own node gives you full control of the node’s configuration, so you can customize to your exact use case. Node providers may not offer the optimal node setup for you.
- Less reliance on middlemen. Running your own node ensures that as long as you can keep the node operational, your platform can broadcast transactions, whereas using a node provider makes you dependent on a third party.
- Safety and security. If you run your own nodes, you have more control over potentially sensitive data your platform is handling.
Cons of running your own RPC nodes:
- Technical complexity. Running nodes requires significant knowledge of blockchain infrastructure that many teams don’t have, and may require an expert hire. Working with a node provider takes this off your team’s plate.
- High setup costs. Running nodes requires significant investment in both hardware and software. Node providers already have these resources up and running.
- Ongoing maintenance and network upgrades. Maintaining your own nodes is an ongoing commitment. For true reliability, you need engineers on-call 24/7 to deal with outages. You also need to keep up with frequent changes in blockchain infrastructure. For instance, running nodes for a rollup requires deep knowledge of your specific rollup technology to handle forks and other changes to the network, as these will impact your nodes. Node providers can handle all of this for you.
- Scaling is difficult. As your platform grows, you’ll need to spin up new nodes and ensure they work properly in concert with your initial nodes. A node provider can handle this work for you.
Ultimately, we recommend that teams work with a node provider unless they have a niche use case requiring a unique node setup, or have deep technical expertise in blockchain infrastructure. Most onchain app and rollup builders choose to go this route.
Autoscaling RPC nodes enable high uptime and cost efficiency
RPC nodes are crucial for app and rollup performance, but platforms relying on a static number of nodes may find themselves running into problems when their usage grows. RPC nodes can only process so much activity at a time, so if your platform’s traffic spikes, your users may exhaust your nodes’ capabilities, leading to degraded performance and failed transactions. That’s why it’s crucial that developers use autoscaling RPC nodes when building crypto platforms.
Autoscaling RPC nodes refer to an advanced infrastructure setup in which the number of RPC nodes utilized by your platform automatically adjusts based on your platform’s traffic. If more people are using your platform, your platform will send RPCs to more nodes. This ensures that during periods of heavy usage, your platform has the RPC nodes it needs to operate smoothly, and that during periods of lower usage, unnecessary nodes are removed from your setup to save you money.
How autoscaling RPC nodes work
Autoscaling RPC node solutions constantly monitor your platform for signs that more RPCs are needed, such as large increases in onchain transactions or a rise in failed transactions. When the system detects that it needs to scale up RPC capabilities, it automatically provisions new nodes and begins sending RPCs to them.
A good autoscaling RPC node solution will also load balance across RPC nodes in use to ensure that all nodes are used efficiently and none are overloaded. Load balancing is also crucial for ensuring consistency in RPC responses across nodes — otherwise, users may receive inconsistent information when using an onchain app, as different nodes are sending different responses. The best autoscaling RPC node solutions load balance in such a way that requests are directed to the most up-to-date nodes in the network, so that users are always getting accurate data from the blockchain.
Since service is scaled up or down dynamically, autoscaling RPC nodes are a variable cost — providers will charge you based on the resources you use each billing cycle. For instance, Conduit charges a base rate to each customer that guarantees them a minimum level of RPC node access, and then an additional fee based on Compute Unit consumption — a unit of measure for RPCs based on the specific call being made — when autoscaling brings the customer’s usage above the minimum.
A good autoscaling RPC node provider will also provide dashboards that allow customers to see just how much node usage they’re being charged for in a given time period. This allows for transparency in pricing. Here’s what the dashboard looks like for autoscaling RPC users on Conduit Nodes:
Users can easily see how far above or below their compute unit minimum they are and quickly understand how much they’re going to be billed. Conduit also offers a spend management tool builders can use to specify the maximum they’re willing to spend on RPCs in a billing cycle, and have autoscaling automatically stop if they reach that maximum.
Autoscaling RPC nodes in action: Conduit Nodes enables a smooth $MODE airdrop
Major airdrops can put major strain on the RPC capabilities of a rollup, as thousands of users rush to claim their share at once. The Mode airdrop is a perfect example.
Mode is an ecosystem rollup deployed with Conduit on the OP Stack, with over 367,000 users. Its May 2024 airdrop was one of the most active of the year, with over 80,000 addresses claiming $MODE on the first day. The network processed over 200,000 transactions in the first hour of the airdrop, with TPS peaking at 80.
What did that mean in RPC terms? RPC requests shot up 80x in minutes, with over 220 million in the first hour and a peak of 19,000 per second. Thanks to Conduit Nodes’ autoscaling RPC capabilities, Mode handled the increased activity with no downtime or degradation in performance. And by outsourcing this functionality to Conduit, Mode was able to spend the days leading up to the airdrop focused on making the event a success for users, and not spinning up more nodes.
Autoscaling RPC nodes are your platform’s key to stable, cost-efficient performance
RPC nodes are crucial to any onchain platform’s performance, and autoscaling RPC nodes are the best way to guarantee you always have the node access you need, without paying for nodes you aren’t using.
If you’re looking to build on a chain deployed with Conduit, then Conduit Nodes is the autoscaling RPC node solution you need. We’re the primary node operator for all Conduit chains, meaning that we can provide unparalleled speed and reliability for all your RPC needs when building on those chains. You can get started with Conduit Nodes by getting an API key here.