Deep dive into Monad: Speed, performance and more

Monad is an EVM-compatible L1 engineered for high throughput through parallel execution, superscalar pipelining, and an optimized JIT-based EVM. Its position as the first token sold on Coinbase’s Token Sales platform drew attention, but the protocol’s real value lies in its architecture: an execution environment that preserves Ethereum compatibility while significantly increasing speed and scalability.

Founded in 2022 by Keone Hon, James Hunsaker, and Eunice Giarta, is an EVM-compatible layer-1 that rethinks Ethereum’s performance constraints at the systems level. The chain’s design focuses on parallel transaction execution, a compact and asynchronous state database (MonadDB), and an EVM runtime with a JIT compiler that optimizes opcode execution globally rather than step-by-step.

After surpassing 102M daily testnet transactions and targeting a Nov 24 mainnet launch, Monad positions itself as a high-performance L1 that maintains full EVM bytecode compatibility. This article details how Monad’s architecture works, how it preserves decentralization while scaling execution, and what developers gain from an environment designed for low-latency, high-throughput smart contract workloads.

Earlier in November 2025, Coinbase, the second-largest cryptocurrency exchange, announced the launch of its token sale platform that lets both institutional and retail investors buy new crypto assets before they are listed for public trading on the exchange. 

Monad, with ticker MON, became the first token launched on the platform, sparking interest in the blockchain.

An X post announcing that Monad’s protocol token (MON) will hold its first public sale on Coinbase’s Token Sales platform.

Monad is an Ethereum Virtual Machine (EVM)-compatible blockchain but also a separate Layer-1 (L1) with a unique architecture that improves speed, performance, and scalability compared to Ethereum and the EVM.

Monad launched its testnet in February 2025, with over 102 million transactions daily to date, and plans to go live on the mainnet on November 24, 2025, following its token sale.

Inspired by its founders’ motivation and as outlined in its mission, its three pillars are the driving force in its technical architecture:

1. Ethereum Virtual Machine (EVM) compatibility 
2. Speed, performance, and scalability
3. Decentralization

This article explains what a Monad is, how it maintains these three pillars without compromising the others, and how developers can benefit from using a Monad.

EVM-compatibility

Monad’s overarching goal is to redesign Ethereum to unlock high-performance applications, not to completely overhaul the Ethereum developer onboarding experience, as the Ethereum ecosystem has the most developers and transaction activity.

Monad founder Keone Han recently explained in a BitGo interview that’s why Monad is EVM-compatible, rather than a non-EVM-compatible L1. 

@Monad in Motion

Smart Contracts

Developing smart contracts on Monad is the same as on Ethereum; however, running them is quicker.

Developers can explore the top Monad contracts, recognizing that they adhere to the same standards and formats on Ethereum.

An example of the USDC stablecoin smart contract on Monad, viewed in the Monad explorer. Source: MonVision 

Already-compiled Ethereum smart contracts can deploy directly to Monad using popular tools such as Hardhat and Foundry, as exemplified in these tutorials. They do not need to be recompiled or modified, as Monad is compatible with EVM bytecode up to the Cancun hard fork. Contracts already compiled to Monad are then cached and not recompiled unless heavily used.

Monad executes new smart contracts faster by using a Just-In-Time compiler that analyzes the entire code and finds the optimal execution path. In contrast, Ethereum executes code line by line.

For example, with these opcodes or instructions converted from code, Ethereum would run each instruction one at a time, charging gas for each instruction. 

The Monad compiler would detect and optimize the PUSH codes into a single line before execution, saving time.

The Monad compiler also improves performance by identifying the location of each opcode on the EVM machine and choosing the fastest way to access it.

The smart contract development process on Monad is quicker and more gas-efficient, yet remains familiar to Ethereum developers.

Speed, Performance, and Scalability

Using Monad is also meant to be faster, not only for developing smart contracts. Monad implemented an architecture that enhances each lifecycle blockchain process, from data storage to transaction execution and consensus on block creation, and enables them to run each stage in parallel. 

Parallel execution

Many blockchains execute transactions one by one, causing delays as they scale. In contrast, Monad executes transactions in parallel, enabling multiple transactions to run concurrently while still preventing the typical issues associated with parallel execution.

First, a blockchain data store must support efficient, simultaneous reads and writes, as transactions require current data on the user’s account and result in updated data. MonadDB, Monad’s built-in database, enables simultaneous reads and writes of the blockchain state via asynchronous I/O, allowing other processes to continue while a read or write completes. MonadDB is more efficient than the Ethereum data store because it compresses historical data. It also uses a more compact data structure (the Patricia Trie) than Ethereum does (the Merkle Patricia Trie).

Example of a Patricia Trie:

Example of the same data represented in a Merkle Patricia Trie, which incorporates additional data types within each child:

Optimistic parallel execution in a Monad prevents a common transaction conflict issue, where transactions to and from the same account might conflict if they occur around the same time.

For example, suppose Alice, who initially has 1000 USDC, sends Bob 100 USDC, and immediately afterward, sends him another 100 USDC.

The second transaction might fail because the system expects Alice to have 1000 USDC, but she should now have 900 USDC.

With optimistic parallel execution, Monad recognizes that both transactions occurred and then commits the final state, showing Alice with 900 USDC.

The system reviews the overall transaction data and the results of the data before finalizing the blockchain state.

Monad founder Keone Han also makes an alternative explanation here. The full technical implementation of the execution client is available here.

Consequently, with parallel execution, Monad can process significantly more transactions. For example, Ethereum processes an average of 18.2 transactions per second (TPS), while Monad approximates that it can handle 10,000 TPS and recently processed 2,000 TPS.

Optimizing execution and consensus

One reason Monad is faster and more scalable is that execution and consensus can happen simultaneously. 

Monad uses superscalar pipelining, dividing blockchain processes into multiple stages and running them concurrently. This allows several lifecycles to happen simultaneously. A real-life example is doing multiple loads of laundry at once, with washing, drying, folding, and storing different loads all happening at the same time.

The implementation also allows Monad to scale because it does not have to fit so many processes into the required 400-millisecond window to create a block. 

Many blockchains utilize interwoven execution, requiring both execution and consensus to occur within a set block time. Often, execution is limited to just 50 milliseconds out of the total 400 milliseconds. While it might seem advantageous that the entire process takes only 400 milliseconds and execution takes 50 milliseconds, this restriction is actually limiting. It prevents increases in block gas, contract complexity, or transactions per block; otherwise, the system risks crashing because it cannot execute transactions within 50 milliseconds.

Instead, Monad separates execution via asynchronous execution, allowing it to run concurrently with consensus.

Securing block creation

Besides execution speed, Monad uses a different consensus model, MonadBFT, to ensure more secure and efficient block creation.

In standard Byzantine fault-tolerant systems, such as those on Ethereum, validators may collude by intentionally going offline or refusing to validate others’ proposals, leading to invalid block proposals. The subsequent validator can then reorder transactions within the block, facilitating a miner-extractable value (MEV) attack that is specifically called tail-forking.

To address this issue, MonadBFT stores the metadata of a proposed block by an honest leader who received at least a majority of votes from other honest validators, and guarantees that it will eventually be finalized and not abandoned.

In such cases, the new leader reaffirms the current proposal to keep it active. If they propose something new, they need to submit signed attestations showing that most validators didn’t receive the previous block.

MonadBFT also streamlines the distribution of blocks to all validators. Because blocks can be large, RaptorCast, an enhanced messaging layer, splits the block into many smaller chunks using erasure coding instead of sending the entire block to all nodes.

For example, a 1000 kb block encoded with a factor of 3 results in about 150 chunks of 20 kb each, with any 50 or so chunks sufficing to rebuild it.

These validators then relay their chunks through a two-step process. The leader sends a chunk to the assigned validator, and the assigned validator then sends it to the rest of the network. The number of chunks each validator manages is proportional to its stake.

The full technical implementation of the consensus client is available at Monad GitHub.

Decentralization

Monad prioritizes performance and scale, while avoiding the sacrifice of decentralization.

Their hardware requirements for becoming a validator or participating in transaction validation on Monad meet performance needs while staying affordable for many individuals. The hardware needed to run a qualifying node with the required specifications costs around $1,500.

On the Monad testnet, 174 validators are spread across 53 cities in 25 countries, without any specific regional focus.

A Nakamoto coefficient, a metric that measures how decentralized a blockchain is and how distributed its validator network is, will be released when Monad launches its mainnet.

Conclusion

Earlier in November 2025, Monad attracted significant interest when Coinbase announced it as the first protocol token to launch on its Token Sales Platform.

Monad is unique due to its dual nature as both an L1 and an EVM-compatible. 

Monad’s vision is to redesign Ethereum to be faster, more performant, and scalable, without completely changing the developer or user onboarding experience, or compromising decentralization. Therefore, it is EVM-compatible. However, to achieve its vision, it needed to build a completely different architecture from Ethereum and become its own separate L1.

Parallel transaction execution, dynamic and compact data storage via MonadDB, and pipelining make it super fast, while MonadBFT, its consensus protocol, ensures that it is secure and scalable.

You can get started with Monad today via Chainstack. Chainstack gives you the performance and consistency required for production systems. Deploy a Monad RPC endpoint in seconds and scale globally with automated orchestration, uptime guarantees, and developer-friendly tooling.

How to create a Monad RPC node

Set up a Monad RPC node on Chainstack:

• Log in to your Chainstack account (or create one if you don’t have it yet).
• Create a new project or select an existing one.
• Pick the Monad chain and choose mainnet.
• Deploy a node configured for RPC access.
• Once deployed, your private RPC URL is available in the node dashboard.

Additional Resources

• Monad Developer Documentation
• Monad Developer GitHub (including examples, tutorials, and explanations)
• Monad source code
• MonVision — Monad Block Explorer