Ethereum processes transactions sequentially. One transaction executes, the state updates, the next transaction executes against the new state. The mental model is a queue. Solana does something different: it executes transactions in parallel across accounts, running thousands of state updates simultaneously within a single slot. That design is why Solana can sustain 5,000+ real TPS while Ethereum’s base layer sits at 15–30.
But parallel execution creates parallel demands on every node that tracks the chain. A node that processes state updates sequentially falls behind the network in seconds during high-load periods. Running a dedicated Solana node that can actually keep pace with Solana’s execution model requires understanding what the model demands and building infrastructure that matches it.
For a comprehensive technical breakdown and deployment instructions, you can follow this detailed walkthrough: https://rpcfast.com/blog/solana-rpc-node-full-guide
How parallel execution works on Solana
Every Solana transaction declares upfront which accounts it will read from and which it will write to. This declaration is not optional—it’s part of the transaction structure. The banking stage reads these declarations to build a conflict graph: transactions that touch different accounts have no conflicts and can execute simultaneously. Transactions that share a writable account must serialize.
In practice, this means that during a busy epoch, hundreds of transactions run in parallel across different account sets while a smaller number queue for access to hot accounts—popular AMM pools, token mints, lending protocol state. The scheduler’s job is to maximize parallelism while respecting the serialization constraints.
For a node tracking this execution, the challenge is maintaining a consistent account state across all the parallel updates. The accounts database must handle simultaneous reads and writes from multiple execution threads without corruption, and it must do so fast enough that the state it reports to API clients reflects the current slot, not the last one.
What parallel execution demands from storage
Solana’s accounts database stores the current state of every account on the network—several hundred gigabytes in 2026 and growing. When the banking stage executes transactions in parallel, it reads and writes account state concurrently across multiple threads. The storage layer must support high-IOPS random access without serializing those requests into a queue.
This is why NVMe drives with high random read IOPS—500,000+—are a hard requirement, not a recommendation. A drive that handles sequential writes well but serializes random reads will create a bottleneck that the parallel execution model constantly hammers. Enterprise NVMe drives maintain high random IOPS under concurrent load because their internal controllers handle request queuing differently than consumer drives.
It’s also why accounts and ledger storage must be separate. Ledger writes are sequential and continuous. Accounts access is random and concurrent. When both workloads compete for the same drive’s queue depth and bandwidth, both degrade. The accounts workload is more sensitive—degraded random IOPS directly increases the time the banking stage spends waiting for state data, which directly increases slot processing time.
What parallel execution demands from RAM
The accounts database performs best when the most-accessed account data lives in memory rather than on disk. Solana’s memory-mapped account storage (Accountsdb) uses the OS page cache to keep hot accounts in RAM—but only if there’s enough RAM to hold them there.
A node with 128GB RAM on a network where the active account set exceeds that size spends significant time on disk reads for accounts that would otherwise be cached. Each cache miss adds latency to the banking stage. With 512GB RAM, the hot account set stays in memory across typical usage patterns and the cache miss rate drops dramatically.
The RAM requirement has grown as Solana’s state has grown. What was sufficient in 2023 is inadequate in 2026. Teams that sized their infrastructure two years ago and haven’t upgraded may be experiencing gradual performance degradation that traces directly to RAM pressure rather than any single acute failure.
What parallel execution demands from CPU
The banking stage runs multiple execution threads simultaneously. More physical cores means more parallel execution capacity. But Solana’s thread model makes single-thread performance matter in ways that pure core count doesn’t capture.
When transactions conflict on a hot account, they serialize onto a single thread. The speed of that thread determines how fast conflicting transactions clear the queue. A processor with high single-core clock speed clears conflicts faster than one with more but slower cores. The recommendation of 3.8GHz+ isn’t arbitrary—it’s calibrated to Solana’s serialization patterns under load.
L3 cache size matters for a similar reason. The banking stage accesses the same account data repeatedly as it processes related transactions. When that data fits in L3 cache, access latency is nanoseconds. When it misses to DRAM, access latency is tens of nanoseconds. A large L3 (32MB+) keeps more of the hot account set in cache across the banking stage’s working set.
The network layer: receiving parallel updates
Parallel execution produces parallel shreds. As the leader executes multiple transaction batches simultaneously, it broadcasts shreds from all of them concurrently. A node receiving these shreds must process them fast enough to reconstruct the full block before the next slot begins.
This is where network bandwidth and processing capacity interact. A 1Gbps connection with insufficient CPU to process the incoming shred stream creates a processing queue that grows until it falls behind. A 10Gbps connection with adequate CPU processes shreds as fast as they arrive. The bandwidth requirement is the easier part—10Gbps is standard for production Solana infrastructure. The processing requirement means that the CPU handling the networking stack must have dedicated resources rather than competing with the banking stage for the same cores.
This is why Firedancer’s tiled architecture—dedicated threads per pipeline stage—outperforms Agave under high-load conditions. The networking tile handles shred reception on its own cores. The banking stage runs on its own cores. They don’t compete, and neither one falls behind because the other is busy.
The node that can’t keep up
When a node’s hardware falls short of Solana’s parallel execution demands, the failure mode is gradual and hard to diagnose. Slot lag increases slowly as the network’s throughput grows. Account lookups take slightly longer. Subscriptions deliver data that’s consistently one slot stale. API responses are technically correct—just slow.
The cumulative effect on any application using that node is a systematic latency penalty on every operation. A trading bot sees the market a slot late. An arbitrage agent acts on account state that’s already changed. A DeFi protocol’s liquidation monitor identifies positions a second after they were already handled by a faster node.
Solana’s parallel execution model is the reason the network can sustain its throughput. It’s also the reason that infrastructure built without understanding those demands fails in ways that are difficult to attribute and easy to dismiss as application-layer problems. The node that keeps up with Solana’s execution model is one built specifically around the demands that model creates—fast random-access storage, high-bandwidth RAM, strong single-thread CPU performance, and dedicated network processing capacity.




