How to run a Solana Node in a few steps

As Solana cements its place as one of the fastest-growing blockchains in crypto, the demand for powerful node infrastructure is soaring. And for good reason, running a Solana node is one of the most direct ways to participate in the network, no matter if you’re looking to unlock earning potential, contribute to decentralization, or simply understand how one of the industry's most ambitious projects actually works under the hood. Solana’s focus on scalability and high-performance design sets it apart from older networks like Ethereum, offering a different approach to blockchain technology and infrastructure innovation.

Think of it this way, most people interact with blockchains from the outside: trading tokens, using apps, maybe staking through a wallet. Running a node puts you on the inside. You're helping secure one of the fastest networks in the world, watching transactions get processed in real time, and gaining a level of insight that's impossible to get any other way. It’s also one of the most hands-on methods to understand how modern computing platforms coordinate data, consensus, and network performance at scale.

This guide will walk you through everything you need to know. We'll cover the types of nodes you can run, the hardware requirements, the setup process, and the practical tips for keeping your node healthy and synced. No advanced engineering background required, just a willingness to get your hands dirty and see what happens when you become part of the infrastructure instead of simply using it, a small but meaningful step into the world where blockchain technology and real-time distributed systems meet.

Understanding Solana Nodes: types and benefits

What is a Solana Node?

A Solana node is a computer that participates in the Solana blockchain network by storing data, validating transactions, and maintaining network consensus. Think of it as your personal gateway to the Solana ecosystem that gives you direct, unfiltered access to blockchain data.

Validator vs RPC Nodes

Let’s first break down the difference between these two node options. What works best for you usually comes down to your interests, technical background, and what you want to get out of it.

Validator Nodes actively participate in consensus by voting on transactions and producing blocks. They require significant hardware resources and a stake of SOL tokens. Validators earn rewards for their participation but also face potential penalties (slashing) for malicious behaviour.

RPC Nodes serve data to apps and users without participating in consensus. They're easier to run, don't require staking, and are perfect for developers who need reliable blockchain data access for their apps.

Solana previously supported archiver nodes, which stored pieces of network history. These are no longer part of the current architecture. Most users choose RPC or validator nodes depending on whether they want to serve applications or participate directly in consensus.

Benefits of running a Solana Node

Running your own node offers the following advantages:

• Earning potential: Validators can earn up to  5-8% APY on staked SOL, while RPC nodes can in some case generate revenue through API access fees
• Network independence: No reliance on third-party providers that might have downtime or rate limits
• Data sovereignty: Complete control over your blockchain data access and privacy
• Learning opportunity: Deep understanding of blockchain infrastructure and Solana's architecture
• Network contribution: Help decentralise and secure the Solana network

Hardware requirements and costs

Getting the hardware right is obviously incredibly important for node performance. Before we get into that, let’s first introduce you to Agave.

Essentially, Agave is a validator client for Solana, providing the backbone of validator and RPC node software in the Solana ecosystem. Initially forked from Solana Labs, it now enables independent, optimised deployment and is central to the multi-client future of Solana.

If you’re thinking about running a validator or RPC node on Solana, Agave is the client you’ll most likely use (recommended by Solana). 

In short: if you care about your node staying healthy, fast, and compliant with the Solana network as it evolves, you will likely use Agave.

Minimum vs recommended specifications

Here are the official Agave requirements:

CPU:

• Validator: 2.8GHz base clock or faster, 12 cores/24 threads minimum
• RPC Node: 16 cores/32 threads or more
• AMD Gen 3+ or Intel Ice Lake+ required
• AVX2 instruction support mandatory (AVX512f helpful)
• SHA extensions instruction support

RAM:

• Validator: 256GB minimum
• RPC Node: 512GB minimum (1TB recommended for full account indexes)
• ECC memory strongly suggested

Storage: PCIe Gen3 x4 NVMe SSD or better required for each:

• Accounts: 1TB+ with high TBW rating
• Ledger: 1TB+ with high TBW rating
• Snapshots: 500GB+ with high TBW rating
• OS: 500GB+ (SATA acceptable)
• Not recommended to store accounts and ledger on the same disk

Network: 1Gbps symmetric minimum, 10Gbps preferred for mainnet 

Operating system: Ubuntu 24.04 (20.04 support ended May 2025)

Hosting options for Solana Validators

Validators don't necessarily need to be "hosted" by third-party providers - you have several options:

1. Self-hosted (own hardware)

• Buy and run your own server at home or in a private data centre.
• Pros: Full control, no recurring hosting fees.
• Cons: Requires enterprise-grade internet (1-10 Gbps), reliable power, security, and 24/7 monitoring.

2. Colocation hosting

• Place your hardware in a professional data centre.
• They provide: Power, cooling, internet, and physical security.
• You handle: Hardware upkeep, software, and monitoring.
• Cost: $100–$500/month + hardware.

3. Dedicated server hosting

• Rent servers from providers (Hostkey, Cherry Servers etc.).
• They provide: Hardware + data center services 
• You handle: Validator setup and monitoring.
• Cost: €349–$1,800+/month (depending on service and location)

4. Cloud hosting (not recommended)

• AWS, GCP, and Azure are possible but discouraged for mainnet due to performance issues and higher operational complexity. 

Official Solana documentation warns: "Running an Agave node in the cloud requires significantly greater operational expertise" and "Do not expect to find sympathetic voices should you choose this route."

Prerequisites and preparation

Before diving into the setup, ensure you have:

SOL requirements: For validators, you'll need a minimum stake (currently around 1 SOL for vote account rent, plus your desired stake amount). RPC nodes don't require staking.

Technical skills: Basic command-line experience, understanding of Linux systems, and familiarity with SSH connections.

Security setup: Strong passwords, SSH key pairs, and a plan for securing your validator keys.

Network planning: Ensure your internet connection meets bandwidth requirements and has minimal downtime.

Your step-by-step Solana Node setup guide

Phase 1: Local machine preparation

Step 1: Install Solana CLI on your personal computer

• Open terminal on your local machine (not the server)
• Download and run the Solana CLI installer from the official release page
• Verify installation by running the version command to confirm successful setup

Step 2: Create essential keypairs

• Generate validator identity keypair and save as validator-keypair.json
• Create vote account keypair (validators only) and save as vote-account-keypair.json
• Generate authorised withdrawer keypair and save as authorised-withdrawer-keypair.json

CRITICAL SECURITY: The authorised-withdrawer keypair controls your validator's funds. Store it securely offline using a hardware wallet, multisig, etc. Never store this file on your validator server.

Step 3: Configure CLI and create Vote Account (validators only)

• Set your CLI to use the appropriate network (testnet for learning, mainnet for production)
• Set the validator keypair as your default CLI keypair
• Fund the validator keypair with sufficient SOL for vote account creation and ongoing fees
• Create the vote account on the network using the three keypairs

Step 4: Secure the withdrawer key

• Backup the authorised-withdrawer-keypair.json to multiple secure locations
• Remove the withdrawer keypair from your local machine after backup
• Verify you can access your backups before proceeding

Phase 2: Server hardware setup

Step 5: Provision your server

• Set up a server meeting the hardware requirements (dedicated public IP essential)
• Install Ubuntu 24.04 on the system
• Ensure all drives are properly connected and recognised

Step 6: Initial server configuration

• Connect to your server via SSH
• Update all system packages to latest versions
• Install essential build tools and development packages

Step 7: Create dedicated user account

• Create a new user account (typically named "sol" or "solana") for running the validator
• Add the new user to the sudo group for administrative access
• Configure passwordless sudo for convenience (optional but recommended)

Step 8: Storage configuration

• Identify and format your NVMe drives for accounts, ledger, and snapshots
• Create mount points for each drive: /mnt/accounts, /mnt/ledger, /mnt/snapshots
• Mount the drives and set proper ownership to your validator user
• Configure automatic mounting in /etc/fstab to persist after reboots

Phase 3: System optimisation

Step 9: Network and firewall setup

• Configure UFW firewall to allow SSH (port 22) and Solana ports (8000-10000)
• Enable the firewall and verify rules are active
• Ensure your server has a dedicated public IP (NAT not recommended)

Step 10: Critical system tuning

• Create sysctl configuration file to optimise UDP buffers and memory mapping
• Set maximum open file descriptors and memory lock limits
• Configure systemd service limits for file handles and memory locking
• Create security limits configuration for the validator user

Step 11: Apply system changes

• Reload sysctl settings to apply network optimisations
• Restart systemd daemon to recognise new service limits
• Log out and log back in to activate user-level limit changes

Phase 4: Software installation

Step 12: Install Agave Validator Software

• Switch to your validator user account
• Download and install the Solana CLI and Agave validator binary
• Add the Solana binary path to your user's PATH environment
• Verify installation by checking version numbers

Step 13: Transfer keypairs to server

• Securely copy validator-keypair.json and vote-account-keypair.json to the server
• Set proper file permissions (read-only for validator user)
• Never transfer the authorised-withdrawer-keypair.json to the server

Step 14: Create validator startup script

• Create a bin directory in your validator user's home folder
• Write a startup script (validator.sh) with all necessary command flags
• Include paths to keypairs, mount points, network entrypoints, and optimisation flags
• Make the script executable and test it manually first

Phase 5: Service configuration and testing

Step 15: Test manual startup

• Run the validator startup script manually to verify it works
• Monitor the initial startup process and log output
• Check for any immediate errors or configuration issues
• Stop the manual process once confirmed working

Step 16: Create system service

• Create a systemd service file for automatic startup and management
• Configure the service to run as your validator user
• Set up automatic restart policies and logging configuration
• Enable the service for automatic startup on boot

Step 17: Verification and monitoring

• Start the validator service and monitor initial synchronisation
• Verify your validator appears in the gossip network
• For validators: confirm your vote account is visible in the validator list
• Set up log monitoring and performance tracking tools

Step 18: Final checks and go-live

• Verify all system resources are performing adequately
• Confirm network connectivity and peer connections
• For validators: ensure sufficient SOL balance for ongoing vote fees
• Set up monitoring alerts for downtime, performance issues, or errors

Phase 6: Ongoing operations

Step 19: Implement monitoring

• Set up Agave Watchtower or similar monitoring tools on a separate machine
• Configure alerts for validator downtime, performance degradation, or sync issues
• Implement automated restart procedures for common failure scenarios

Step 20: Establish maintenance procedures

• Create regular update procedures for Agave software releases
• Implement log rotation to manage disk space
• Set up backup procedures for configuration and keypairs (except withdrawer)
• Document troubleshooting steps for common issues

Profitability and economics

Earning potential

Validator Rewards: Current estimates suggest 5-8% APY on staked SOL, though this varies based on network conditions and your validator's performance.

RPC Revenue: Can generate income through API access fees, though this requires building a customer base.

Running a validator isn't without risks:

• Slashing: Poor performance can result in stake penalties
• Hardware costs: Equipment failures require immediate replacement
• Market volatility: SOL price fluctuations affect reward values

Break-even analysis

According to online forums, some operators claim to have broken even after 12-18 months, depending on initial hardware investment, operational efficiency, SOL price stability, and network reward rates.

Tips for running a successful node

Running a successful node requires more than just initial setup. It demands ongoing attention and the right infrastructure. Start with enterprise-grade hardware for stability, and if you're serious about uptime, consider hosting your machine in a data center with redundant power and internet to minimize downtime risks. Security should be a top priority: never store validator keys on shared servers, and always enable firewall and DDoS protection to shield your node from attacks. Monitoring is equally critical. You may set up automated alerts for disk space, RAM usage, and network performance so you can catch issues before they escalate.

Beyond the technical requirements, community support can make a significant difference in your experience. Join validator Discord groups where experienced node operators share insights, troubleshoot problems, and discuss best practices in real time. Tools like Grafana can help you visualize your node's performance metrics and identify optimization opportunities. Whether you're running an RPC node to support decentralized applications or operating a validator to earn staking rewards, remember that node operation isn't "set and forget." It requires consistent attention, especially on mainnet where downtime can impact both network performance and your reputation within the Solana ecosystem. The investment in time and resources pays off through deeper blockchain knowledge, potential earnings, and the satisfaction of contributing to one of crypto's most innovative computing platforms.

Conclusion and next steps

Running a Solana node can be rewarding both technically and financially in some cases, but it requires significant commitment and resources.  Be sure to consider your technical expertise, available capital, and long-term goals when deciding between self-hosting and alternative solutions.

For additional resources, consult the official Solana documentation and join the validator community on Discord for ongoing support and updates.