Blockchains are often limited not by ideas, but by speed. If a network can only process a small number of transactions per second (TPS), it will slow down, become expensive, and fail to support real-world apps. NEAR Protocol has just passed a major milestone: a publicly verifiable benchmark of over 1 million TPS using real NEAR code, realistic workloads, and affordable cloud hardware.
In this article, we’ll unpack what this result means, how the test was done, and why it’s important for the future of DeFi, onchain AI, and large-scale Web3 applications.
What Is TPS and Why Is 1 Million a Big Deal?
TPS (transactions per second) is a simple measure: how many actions a blockchain can process every second.
You can think of it like checkout lines in a supermarket:
Few lines open → long queues and angry customers
Many lines open → people move quickly, even at rush hour
Most blockchains today still act like a single big checkout line. When many users arrive, the network gets congested and fees rise. Hitting 1 million TPS in a realistic test shows that NEAR can behave more like a whole mall full of checkout lines, ready for huge spikes in traffic.
NEAR’s Scaling Approach: Sharding in Simple Terms
Most older blockchains are monolithic: they process everything on one big chain. This design has a natural ceiling.
NEAR was designed differently, as a sharded L1 (layer-one) blockchain. Sharding means splitting the network into many parallel parts called shards, each handling its own slice of data and transactions:
More shards → more total TPS (this is called horizontal scaling)
Costs stay low and predictable
Validators (nodes that secure the network) can use normal, affordable hardware
Recent upgrades like Nightshade 2.0 and stateless validation make this design more efficient. NEAR has already scaled to 9 shards on mainnet, with 600 ms blocks and 1.2 second finality—meaning transactions are confirmed very quickly and securely.
This architecture is especially useful for:
High-volume cross-chain DeFi
Real-time applications
Onchain AI agents making rapid decisions and payments
How the 1M TPS Benchmark Was Designed
A benchmark is like a stress test for the network: “How far can we push it under realistic conditions?”
The NEAR engineering team set strict rules so the test would be credible and reproducible:
Use real NEAR core code from the main development branch
Run on hardware that real validators can afford (around $1,000/month cloud machines)
Use a reasonable shard count (up to 80; test ran at 70 shards)
Make it publicly verifiable so anyone can re-run it
Provide an open dashboard with detailed TPS data
In other words, this was not a fake “lab trick” with special code. It followed similar constraints to what validators see in production.
The Setup: 70 Shards and Realistic User Activity
To model real user behavior, the team configured the benchmark with:
70 shards
1 million accounts per shard
Only native token transfers (no smart contract execution) to measure raw throughput
Account activity following Zipf’s law, a pattern where a few accounts are very active and many are less active—similar to real networks
Uniform cross-shard traffic so transactions moved between shards, not just inside one
Transactions were sent directly into the mempool (the “waiting room” where transactions sit before being included in a block). RPC endpoints (external APIs) were not part of this test, since they are off-chain infrastructure. The team also removed the block gas limit to see the true upper limit of throughput.
The hardware used was Google Cloud C4D virtual machines with 5th Gen AMD EPYC processors and Hyperdisk storage, spread across three regions. These machines cost about $900/month each and delivered around 45% better performance than the previous generation—while staying within the target validator budget.
The Results: Stable 1,000,000+ TPS
During the benchmark window, NEAR:
Peaked at over 1,000,000 TPS across 70 shards
Maintained stable block production and predictable throughput
All runs are visible on a public Grafana dashboard, and the exact code commit plus open-source scripts are available so others can reproduce the results. The team notes that on bare-metal servers (used by many mainnet validators), performance would likely be even higher.
To reach this level, engineers optimized many layers:
Faster execution and signature verification (checking who signed each transaction)
Rewrites and tuning of the Trie and database layers (how blockchain state is stored and updated)
Optimistic execution paths that reduce waiting where possible
Consensus and stateless witness optimizations
Network tuning to improve communication between nodes
They also built a custom trace analysis tool to study timing inside each block and identify bottlenecks.
Why This Milestone Matters for NEAR and Web3
This 1M TPS result supports NEAR’s claim to be a truly scalable, future-proof protocol. It is especially important for:
NEAR Intents and cross-chain volume
Onchain AI agents that may execute thousands of micro-transactions per second
Enterprise systems that need confidential AI compute and high throughput
Just as important as the speed is how it was achieved:
No special supernodes
No proprietary or centralized sequencer
No hidden monolithic bottleneck
NEAR keeps hardware requirements low and continues to expand validator seats, helping maintain decentralization and a diverse validator set.
What Comes Next for NEAR Scalability
This benchmark is not a separate experimental branch. Most of the core code used for 1M TPS is already on mainnet, and the remaining optimizations are coming in version 2.12.
The NEAR team is now focusing on:
Dynamic resharding (automatically adjusting the number of shards as demand changes)
Sharded smart contracts, so contract execution is also fully distributed
Further execution and Trie optimizations
Decoupling consensus and execution to reduce block times even more
Scalable RPC infrastructure
More detailed performance reports and additional public benchmarks
The long-term vision is clear: a blockchain that can scale indefinitely, stay decentralized, remain cost-efficient, be easy to build on, and remain secure—supporting a multi-chain world and the fast-growing onchain AI economy.
Key Takeaway and Reflection
NEAR’s 1 million TPS benchmark is not the final destination. It is a proof point that the protocol’s sharding-first design can support the next generation of high-volume, AI-driven, and cross-chain applications—without sacrificing decentralization or pushing hardware requirements out of reach.
To deepen your understanding, consider:
How does sharding compare, in your mind, to adding more lanes to a highway?
Why is it important that NEAR’s benchmark can be reproduced by anyone, not just the core team?
What kinds of apps or AI agents could truly benefit from 1M+ TPS capacity?
How might dynamic resharding and sharded smart contracts change how developers design dApps in the future?