Quicknode

June 9, 2025 — 12 min read

Building on blockchains has been long-associated with trade-offs. Faster execution often means centralization. Compatibility usually comes at the cost of performance.

Fighting this, developers have built workarounds, accepted limitations, and architected applications around the constraints of existing infrastructure. Layer 2 solutions promised relief but introduced new complexities — bridging mechanisms, liquidity fragmentation, and additional security assumptions.

But, Monad brings developers a unique promise: a rare balance of high throughput, low latency, and seamless integration with existing Ethereum tooling.

Monad promises to eliminate all trade-offs and in this blog, we will cover Monad’s architecture, what features set it apart, and help developers get started on building with the help of Quicknode.

Unbundling Monad: The Foundations of the Blockchain

Monad is a layer 1 blockchain that offers something rare in web3: performance without trade-offs.

It brings together high throughput, low latency, and full EVM compatibility — without asking developers to change how they build. By rebuilding core execution and consensus mechanisms while maintaining Ethereum compatibility, Monad creates new possibilities for onchain applications.

What makes Monad unique?

1. MonadBFT ensures fast, reliable consensus with built-in resistance to common failure conditions like tail-forks.

2. RaptorCast speeds up how blocks move through the network, minimizing delays in propagation.

3. Asynchronous execution decouples execution from consensus, giving the system more room to compute without slowing down.

4. Parallel execution processes many transactions at once—boosting throughput without breaking determinism.

5. MonadDB optimizes how state is accessed and stored, reducing the performance hit from high user and contract activity.

Now, let’s dive deeper into the technical foundation that enables Monad to support complex, high-throughput applications at scale.

Under the Hood of Monad: Exploring The Technical Stack

Monad brings in a bunch of architectural innovations to web3 and blockchain development. Let’s learn how these go from being theoretical advancements to concrete advantages for developers building the next generation of decentralized applications.

MonadBFT

Consensus is often the slowest component in a blockchain’s lifecycle. Traditional BFT consensus protocols struggle with tail-fork scenarios where network partitions create competing chain tips, forcing expensive reorganizations that can delay finality for minutes.

MonadBFT rethinks this by offering a performant Byzantine Fault Tolerant consensus that is optimized for high throughput and tail-fork resistance — ensuring honest validators aren’t penalized by network delays or malicious leaders.

Why does MonadBFT matter?

Fast finality (1s) without depending on centralized sequencers or committees reduces risk and improves UX — users and developers no longer wait through multiple confirmations. This also makes high-frequency apps like orderbook DEXs or real-time games viable without sacrificing decentralization.

How does MonadBFT work?

MonadBFT uses pipelined consensus with tail-forking resistance to ensure honest blocks aren’t abandoned, even under network delays.

Leaders repropose supported blocks, enabling fast finality (~1s). A “fan-out, fan-in” message pattern keeps communication linear, and speculative execution supports latency-sensitive apps without sacrificing decentralization.

Asynchrone uitvoering

Traditional blockchains tightly couple consensus and execution, requiring blocks to be fully processed before the next consensus round can begin. This coupling creates artificial constraints on computational complexity and forces developers to architect around consensus timing limitations rather than application requirements.

Asynchronous execution is Monad’s approach to decoupling consensus from execution, allowing both processes to occur in parallel. This design enables each to utilize the full block time, significantly increasing efficiency without compromising determinism.

Why does asynchronous execution matter?

Applications can include computationally intensive logic without being constrained by consensus timing. Complex DeFi protocols with multiple oracle integrations, on-chain AI inference, or sophisticated game mechanics become feasible while maintaining fast block times.

Developers can focus on application logic rather than optimizing around consensus bottlenecks.

How does asynchronous execution work?

Consensus finalizes block headers using MonadBFT, while execution of transactions happens in a separate pipeline. Nodes speculatively execute blocks as they’re proposed, and finalize execution once the header is confirmed.

This model increases throughput by allowing multiple execution rounds to be in-flight simultaneously, without blocking consensus progress.

RaptorCast

Block propagation becomes a critical bottleneck as transaction volumes increase. Traditional blockchain networks suffer from bandwidth limitations where larger blocks take longer to transmit, creating timing variability that impacts consensus stability and increases the likelihood of network partitions or forks.

RaptorCast is Monad’s custom block broadcast protocol, designed to distribute blocks quickly and efficiently across a globally distributed validator set even under high transaction volume.

Why does RaptorCast matter?

Fast block propagation is essential for maintaining low-latency finality and minimizing the risk of forks. RaptorCast ensures that blocks reach validators fast enough to support 1-second finality, enabling real-time apps to operate reliably. By reducing propagation lag, it also helps keep the network synchronized.

How does RaptorCast work?

RaptorCast uses erasure coding to split blocks into smaller chunks that can be transmitted in parallel across multiple network paths. Validators can reconstruct complete blocks from receiving only a subset of these chunks, reducing total bandwidth requirements while providing redundancy.

This approach ensures reliable transmission even when some network paths experience congestion or failures, maintaining consistent block propagation times under varying network conditions.

Parallel Execution

Traditional EVM chains execute transactions sequentially — one after another — to preserve determinism and state consistency. While simple, this model creates a hard cap on throughput and limits the types of applications that can scale effectively onchain.

Monad introduces optimistic parallel execution, allowing many transactions to be processed simultaneously while maintaining compatibility with the EVM and full determinism.

Why does parallel execution matter?

Sequential execution limits performance and makes it difficult to scale real-time applications like orderbook DEXs, onchain games, or AI agents.

Parallel execution removes that bottleneck, enabling high-throughput workloads to settle in a single block. This leads to faster apps, lower latency, and a better user experience without changing how developers write smart contracts.

How does parallel execution work?

Monad speculatively runs transactions in parallel under the assumption they do not conflict. A scheduling layer then analyzes dependencies between reads and writes to detect conflicts. Non-conflicting transactions are committed directly, while conflicting ones are re-executed in a safe order.

This approach maximizes throughput without sacrificing correctness or requiring custom tooling.

MonadDB

State access is one of the most expensive and time-consuming parts of EVM execution. Every smart contract interaction — especially storage reads and writes (SLOAD/SSTORE) — triggers costly operations that slow down block production and limit scalability.

MonadDB is a custom-built storage engine designed to optimize state access, minimize I/O overhead, and support high-concurrency execution.

Why does MonadDB matter?

In high-throughput environments, storage becomes a critical bottleneck. MonadDB reduces the number of disk operations required per transaction, speeding up execution and lowering infrastructure costs.

For developers, this means lower latency, cheaper gas, and the ability to support more users without architectural workarounds.

How does MonadDB work?

MonadDB uses a tree-based data structure optimized for parallelism and caching. State reads and writes are handled asynchronously, allowing multiple threads to fetch and update storage simultaneously.

Combined with Monad’s parallel execution model, MonadDB ensures that high transaction volumes do not slow down the system making it a key enabler of scalable onchain applications.

With Monad’s core architecture and performance innovations now unpacked, the next step is seeing how these translate into real development workflows.

Building and Testing on Monad: A Developer’s Guide

Monad’s technical design isn’t just theoretical, it’s already being put into practice by early teams building and testing high-performance dApps on its testnet. With full EVM compatibility, fast finality, and optimized state access, the developer experience remains familiar while performance scales dramatically.

Live Projects on Monad Testnet

Monad’s testnet has quickly become a proving ground for protocols pushing the limits of onchain performance. From DeFi to NFTs to developer tooling, projects are testing how Monad’s low latency and high throughput can improve UX, reduce costs, and unlock new functionality.

1. DeFi protocols
   Covenant, Euler Finance, Uniswap, Renzo Protocol, and Stargate are deploying to explore faster settlement, tighter feedback loops, and gas-efficient strategies that are impractical on slower chains.

2. NFT platforms
   Magic Eden, Mintpad, and Opensea are testing on Monad to streamline minting flows, reduce listing latency, and support richer, real-time marketplace interactions.

3. Abstraction and onboarding tools
   Biconomy, Dynamic, Thirdweb, Privy, and Web3Auth are integrating to enable seamless user experiences—from gasless transactions to embedded wallets—without compromising security or performance.

4. Wallets
   Wallets like Ambire, Bitget, Bybit, Phantom, and Zerion are ensuring their users can access Monad-native dApps with the same convenience and functionality they expect from EVM chains.

5. Developer infrastructure providers
   Quicknode, Alchemy, Chainbase, Dune

These early integrations demonstrate a growing belief across the stack: Monad’s execution model and developer experience offer a reliable and scalable infra.

Best Practices for Testing and Optimizing Applications on Monad

Monad gives developers the raw performance and flexibility to build at scale—but taking full advantage of its architecture requires a slightly different approach than traditional EVM environments.

Below are key practices that help maximize performance, minimize latency, and ensure dApps run efficiently in production.

Use Production-Grade Infrastructure from Day One

Relying on performant, low-latency RPC providers like Quicknode ensures stable interactions with the Monad testnet during development and production. Quicknode offers:

• HTTPS and WebSocket support

• Monad-specific debug APIs

• Built-in monitoring and logging

• Real-time data with

  Streams

Reduce Latency with Hardcoded RPC Values

Certain Ethereum JSON-RPC methods on Monad always return static values:

• eth_chainId: 10143

• eth_gasPrice: 52 * 10^9

• eth_maxPriorityFeePerGas: 2 * 10^9

Batch RPC Calls to Optimize Performance

Avoid sending multiple individual eth_call requests when fetching data.

• Use Multicall3 on Monad Testnet: 0xcA11bde05977b3631167028862bE2a173976CA11

• For complex workflows, deploy custom batch reader contracts.

• Use batching-capable libraries (like ethers.js batch() or Promise.all() in JS) to reduce round trips.

Index, Don’t Poll

For read-heavy apps or those needing historical data:

• Use indexers instead of eth_getLogs for querying past events or derived states.

• Monad-compatible indexers include:- Quicknode Streams (stream directly to Webhooks, PostgreSQL, etc.)

Manage Nonces Locally for Concurrent TXs

When submitting multiple transactions in rapid succession, don’t wait on eth_getTransactionCount. Monad finalizes blocks fast, but eth_getTransactionCount only reflects confirmed TXs.

Tip: Track nonces locally to avoid errors and submit TXs concurrently. This is especially useful in trading, gaming, or automation flows.

Submit Transactions in Parallel

Monad’s fast finality means there's no need to wait for one transaction to confirm before submitting the next.

Tip: Use asynchronous patterns (e.g. Promise.all() in JavaScript) to dispatch transactions in parallel. This improves throughput and shortens transaction pipelines.

Test for Parallelism and Throughput

Design contracts and frontends to take advantage of Monad’s optimistic parallel execution.

• Avoid unnecessary shared state or contract-level mutexes.

• Favor modular logic that can be executed independently across users.

• Simulate real-world concurrency during testing to surface hidden bottlenecks.

Optimize Hosting and Backend Infra

For frontend and server deployments:

• Static Hosting: Use S3 + CloudFront for scale and low latency.

• Serverless Functions: Use AWS Lambda or containerized apps (ECS/EKS) for backend APIs.

• Databases: Use RDS for relational storage and cache frequently used data to reduce compute overhead.

By aligning with Monad’s architectural strengths and avoiding legacy bottlenecks, developers can build faster, cheaper, and more scalable applications — without changing their Ethereum-native toolkits.

Building on Monad Made Easy with Quicknode

Monad’s architecture unlocks a new class of high-performance applications—but it still needs reliable infrastructure to bring those apps to life. That’s where Quicknode comes in.

Quicknode offers a fully managed, high-speed RPC and developer tooling suite purpose-built for Monad. From initial testing to production deployment, Quicknode makes it easy for developers to start building without worrying about uptime, latency, or observability.

What Quicknode Offers for Monad Developers

• High-Performance RPC Endpoints

Global edge distribution ensures API requests are routed to the nearest node, reducing latency and improving app responsiveness.

• WebSocket Support

For real-time applications, WebSocket endpoints deliver instant access to new blocks, logs, and contract events—perfect for trading platforms, games, or AI agents.

• Monad-Specific Debug APIs

Unlock deeper insight into execution with raw block traces and transaction-level diagnostics to support advanced use cases and faster troubleshooting.

• Testnet Faucet

Easily acquire MON testnet tokens via Quicknode’s faucet — compatible with MetaMask, Coinbase Wallet, Phantom, and more.

• Quicknode SDKs and Examples

Use pre-built examples in JavaScript, Python, cURL, and more to integrate quickly with Monad’s RPC layer.

• Streams for Real-Time Data

Subscribe to blockchain events and push data directly to webhooks, databases, or backends with Quicknode Streams.

Ready to Launch on Monad?

Spin up a free Quicknode endpoint for Monad Testnet and start building in minutes.

No setup. No guesswork. Just speed, scale, and developer-first tooling.

👉 Get started with Monad on Quicknode

Frequently Asked Questions (FAQ)

Can I deploy my existing Ethereum smart contracts on Monad?

Yes, Monad supports full EVM bytecode compatibility. Your existing Solidity contracts will deploy and run on Monad without any code modifications. Development tools like Hardhat, Foundry, and Remix work natively.

Is Monad mainnet live yet?

Monad is currently running a public testnet where developers can build and test applications. The testnet features the full architecture and performance characteristics planned for mainnet.

How do I get testnet tokens for development?

You can claim free MON testnet tokens from Quicknode's Monad Testnet Faucet every 12 hours. The faucet supports connections via MetaMask, Coinbase Wallet, Uniswap Wallet, and Phantom.

Is Monad blockchain secure?

Yes, Monad maintains security through MonadBFT consensus, which is Byzantine Fault Tolerant and runs on decentralized validator infrastructure. The performance gains come from architectural optimizations, not security compromises.

What are some dApps currently live on the Monad testnet?

Uniswap, Euler, Stargate, Renzo Protocol, Magic Eden, Opensea, and others are already testing or integrating Monad.