How Monad handles 10K+ RPS when legacy infrastructure won't work

Meet Monad

Monad is a high‑performance, EVM‑compatible Layer 1 blockchain that delivers high-throughput and low latency while maintaining compatibility with the Ethereum tooling and developer experience that teams already know.

Their story starts in the high-frequency trading world, where Keone Hon and James Hunsaker, two of Monad's three cofounders, spent years shaving microseconds off critical paths, operating right up against physical limits. At that level, you learn which tradeoffs between performance, decentralization, security, scalability, and developer experience are real, and which ones everyone just accepts.

Monad was built to challenge the accepted tradeoffs, rearchitecting practically everything from the ground up to solve the blockchain trilemma without making sacrifices.

When Monad mainnet launched in November 2025, protocols like Uniswap, Chainlink, Morpho, and Curve were all deployed within days. Some immediately at launch. But of course, behind what seemed like a smooth launch was a problem most builders never see.

The problem with traditional blockchain infrastructure

Monad's testnet made one thing clear: their throughput ambitions wouldn’t work on legacy infrastructure built for slower networks.

At 10,000+ TPS, Monad generates archive state faster than traditional infrastructure can store, serve, or scale around. It would immediately break most RPC systems. For developers, this would manifest in different ways:

• Re-indexing failures: Most EVM tooling assumes the availability of a full-archive node. For example, builders would deploy subgraphs and then iterate their indexing logic as they added new features to their applications. On redeployment, the subgraphs would fail because data from several weeks back was no longer available at the RPC layer.
• Historical data wipes: The chain could grow at a theoretical max of 6TB per day, blowing through SSD capacity. Nodes had to aggressively prune, keeping only a few weeks of historical state. Anyone who needed older data had to archive it themselves.
• Parallel scans overwhelmed even powerful infrastructure. Processing millions of blocks by attempting concurrent reads would overwhelm even a high-end node.

Beyond the technical challenges, it was also about minimizing frictions for Monad’s ecosystem builders. Their performance gains don't matter if teams can't build on it the way they build everywhere else.

True to their HFT roots, the team at Category Labs (the core R&D and engineering group behind Monad) refused to accept this as a given and came to Goldsky with a clear vision of what they wanted.

Bigger isn’t always better

Over a 4-week period, Goldsky and Category Labs built a custom RPC implementation in collaboration with Nirvana (a performance cloud and node provider) so that developers could have a vanilla full-archive endpoint out the box.

Goldsky and Category Labs worked together to develop a novel idea: instead of a single continuously-growing archive node, run distributed nodes that freeze when they hit storage limits, then stitch them together behind intelligent load balancing.

To make this model work on Monad, the archive nodes themselves had to be built in a very specific way. Nirvana delivered this through a custom-built archive deployment that underpins the historical guarantees exposed through Goldsky Edge.

Nirvana rebuilt Monad’s history directly from genesis, re-executing every block using Monad’s native tooling on archive-grade hardware with raw block-device access. They continuously replay new blocks to maintain historical correctness as the chain grows. This is the physical foundation that makes the rest possible.

Goldsky's open-source RPC proxy, eRPC, is what ties it all together. eRPC was already built for multi-provider resilience, intelligent routing, and global caching. But what Monad needed was a specific adaptation: eRPC's block availability per node feature defines what range of history each upstream node can serve, so requests route not just for uptime but for which node actually has the history. That's what makes distributed archival storage across sharded nodes work behind a single Edge endpoint.

Edge powers rpc2.monad.xyz, Monad’s single RPC endpoint that orchestrates multiple backend systems into a unified view of chain history:

• Capability-aware routing: Multiple upstreams (full nodes, archive nodes, object storage snapshots, time-sliced indices) are treated as a single logical provider. Each declares what it can serve (e.g. “has historical state”, “blocks only”), allowing queries to route to the right place automatically.
• Historical state reconstruction: For queries like eth_call or eth_getStorageAt at historical blocks, Edge selects the nearest snapshot at or before the target block, then applies forward deltas as needed. It prefetches adjacent data to collapse round-trips during sequential scans.
• Continuous enforcement: Multiple upstreams are continuously checked to ensure consistency. Near-head requests are revalidated to further ensure data quality and prevent flip-flop reads.
• Global caching at the CDN layer: Related requests are grouped and parallelized. Block bodies, receipts, and popular contracts’ storage slots are cached across a global multi-region CDN to drive low latency for hot requests, and scale a single node’s request capacity well beyond its hardware limits.

"We needed infrastructure that could keep pace with Monad's throughput without forcing developers to work around data availability gaps. We had an idea of how we wanted to do it, and working with Goldsky meant we could execute on that vision in days and weeks instead of months." — Austin Green, Monad Foundation

Launch-day readiness in 4 weeks

The initial conversation to production deployment took four weeks.

Edge eliminated the operational risk of running a complex multi-node system, and provided built-in safeguards (e.g. quorum checks, fork-aware stability, circuit breakers) that would otherwise take months to build and years to battletest.

With Edge, Monad mainnet launched with full archive support and major protocols like Uniswap, Morpho, and Euler Finance were able to deploy seamlessly with a mix of Goldsky Subgraphs, Mirror, and Edge.

The new architecture delivered 3 critical capabilities:

Permanent full archive coverage

• 100% of blocks from genesis available through a single endpoint, with historical data preserved indefinitely.
• Deterministic, replayable scans for indexers and analytics, even at 10K TPS.

Developer experience

• Standard EVM tooling works out of the box. Subgraphs and other tooling work the same way they work on Ethereum, Arbitrum, Base, or any other EVM chain. Teams don't need to modify their workflows or build custom solutions.
• Major protocols indexing and serving data on day one. Uniswap, Morpho, and Euler Finance easily deployed at launch using a mix of Goldsky Subgraphs, Mirror, and Edge.

Infrastructure resilience

• Automatic failover, caching, and request multiplexing across distributed nodes.
• Scalable by design. The infrastructure scales with the eventual addition of more frozen + live nodes as Monad grows.

Speed to production

• 4 weeks from first call to production-ready endpoints.
• 1K+ TPS sustained since mainnet launch.

Monad's mainnet launch made it clear that EVM chains don't have to sacrifice developer experience or familiarity for performance, but only if the infrastructure layer can keep up. Goldsky's sharded node approach makes that possible at the RPC and developer-facing layer, while Nirvana supplies the custom-built node infrastructure required at the physical layer.

Ship high-throughput chains without compromise

👋 Hey, we’re Goldsky. We built Edge to help high-throughput chains that are too fast for traditional RPC infrastructure. Whether you’re launching a chain like Monad, or building on them like Uniswap, Polymarket, and Coinbase do, we can help you ship faster without giving up access to the data you need.

Sign up for free (no credit cards or forms to fill) or instantly schedule a call to see how we can support your product.