React
React Native
Node.js
Python
Rust
PostgreSQL
Solana
Claude
AI Agents
Go

Solana Developer SME Guide

Sections

Solana Foundations & Architecture

Solana Foundations In Depth Solana Basics SOL, Lamports & Units Clusters & Networks RPC Providers Slots, Blocks & Epochs Keypairs & Addresses The Solana Mental Model vs. EVM How a Transaction Flows Types of Wallets Block Explorers Wallets & Explorers Solana Fundamentals Best Practices

The Account Blueprint Account Model Basics Account Anatomy Rent & Rent-Exemption System Accounts vs. Program Accounts Program-Owned State Account Ownership & Permissions Data Accounts & Layout Creating & Closing Accounts Account Model Best Practices

Sealevel Runtime Key Points Programs Basics The SVM & sBPF Sealevel Parallel Execution Account Locks & Conflicts Compute Units & Budgets The Program Entrypoint Stateless Programs Program Loaders & Upgradeability Sealevel Runtime Best Practices

The Transaction Transactions Basics Instructions & Accounts Versioned Transactions (v0)Address Lookup Tables (ALTs)The Compute Budget Program Priority Fees Blockhashes & Expiry Simulating Transactions Jito Tips & Bundles Transactions Best Practices

Solana Architecture In Detail Architecture Overview Proof of History (PoH)Turbine Gulf Stream Sealevel Pipelining (TPU/TVU)Cloudbreak & Accounts DB Gossip & Cluster Communication Leader Schedule & Block Production Architecture Best Practices

Consensus In Depth Consensus Basics TowerBFT + PoH Vote Accounts & Voting Introducing Alpenglow Votor Rotor Migration & Developer Impact Confirmation Levels in Clients Consensus Best Practices

Tokenomics Blueprint Economics Basics Inflation & Staking Rewards Staking & Delegation Liquid Staking & LSTs MEV on Solana Priority Fee Markets Governance & SIMDs Realms & On-Chain Governance Economics Best Practices

CLI, Tooling & Local Dev

The Solana CLI Solana CLI Basics Keypairs with solana-keygen Airdrops & Balances Inspecting Accounts & Programs Sending SOL & Transactions Deploying Programs spl-token CLI Logs & Debugging Solana CLI Best Practices

Toolchain Blueprint Toolchain Overview Version Management (agave-install / avm)create-solana-dapp Mucho CLI Building Programs (cargo build-sbf)Verifiable Builds (solana-verify)Editor & rust-analyzer Setup Toolchain Best Practices

Local Dev In Detail Local Dev Basics solana-test-validator Cloning Mainnet Accounts Surfpool Loading Programs & Fixtures Local Logs & Debugging Localnet vs Devnet Workflow Local Dev Best Practices

RPC & WebSockets In Depth RPC Basics Core RPC Methods getProgramAccounts & Filters WebSocket Subscriptions The DAS API Priority Fee & Simulation APIs RPC Providers Pagination & Efficiency RPC Best Practices

Indexing Blueprint Indexing Basics Geyser Plugins Yellowstone gRPC Webhooks Building an Indexer Parsing Program Data Analytics & Dashboards Indexing Best Practices

Landing Transactions Key Points Why Transactions Fail to Land Estimating Compute Units Setting Priority Fees Address Lookup Tables in Practice Retries & Blockhash Management Jito Bundles Transaction Assembly Optimization Best Practices

On-Chain Rust

Rust for Solana Programs Rust for Solana Basics no_std & the Program Environment Borsh Serialization Zero-Copy with bytemuck Safe Arithmetic Working with Pubkeys & Accounts Program Size & CU Discipline Error Handling On-Chain Rust for Solana Best Practices

Native Programs In Detail Native Program Basics The Entrypoint & Dispatch Manual Account Validation Instruction Data (de)Serialization Creating Accounts via CPI Reading & Writing Account Data Emitting Logs When to Go Native Native Programs Best Practices

The PDA Blueprint PDA Basics Deriving PDAs Canonical Bumps Signing with PDAs PDAs as Authorities PDA Account Creation Seed Design & Collisions PDA Security Pitfalls PDA Best Practices

CPIs Explained CPI Basics invoke vs invoke_signed Passing Accounts to CPIs CPI to the System Program CPI to SPL Token CPI Depth & Limits Reentrancy & Safety Composability Patterns CPI Best Practices

Serialization Key Points Serialization Basics Account Discriminators Borsh Structs Zero-Copy Accounts realloc & Growing Accounts Space Calculation Data Versioning & Migration Serialization Best Practices

Pinocchio In Depth Lightweight Frameworks Overview Pinocchio Basics Building a Program with Pinocchio Steel Framework CU & Binary-Size Wins Interop & Migration When to Use Which Framework Lightweight Frameworks Best Practices

Errors, Logs & Events Error Handling Basics Custom Error Enums Logging with msg!Emitting Events Decoding Errors Off-Chain Debugging Failed Transactions Errors & Logs Best Practices

On-Chain Patterns Blueprint Program Patterns Basics Account Initialization Patterns Vault & Escrow State Machines On-Chain Access Control & Authorities Fee & Treasury Patterns Time & Clock Upgrade-Safe Data Design Program Patterns Best Practices

Anchor Framework

Anchor In Depth Anchor Basics Project Structure The #[program] Module The Accounts Struct Building & Deploying The Anchor Workflow Anchor vs Native Anchor Basics Best Practices

Anchor Constraints Explained Account Types The #[account] Constraints init & init_if_needed Space & Rent Seeds & Bump Constraints Token & Associated Token Constraints Custom Constraints Account Validation Order Accounts & Constraints Best Practices

Instructions & Context Instruction Handlers Instruction Arguments Accessing Accounts The System & Token Programs Return Values & CPIs from Handlers Instruction Ordering & Dependencies Instructions Best Practices

PDAs in Anchor Key Points PDAs in Anchor Signing with PDAs Storing Bumps PDA Authorities Client-Side PDA Derivation Common PDA Mistakes PDAs in Anchor Best Practices

Anchor CPIs In Detail CPI Basics in Anchor SPL Token CPIs Signed CPIs CPI to Custom Programs Passing Remaining Accounts CPI Safety CPIs in Anchor Best Practices

Anchor Errors & Events #[error_code] & require!Custom Error Messages Events with emit!emit_cpi! & Self-CPI Events Logging & CU Cost Client-Side Error Decoding Errors & Events Best Practices

IDL & Codegen Blueprint The Anchor IDL declare_program!Generating TS Clients Codama from an Anchor IDL IDL Versioning On-Chain IDLs Codegen Best Practices

Advanced Anchor Key Points Zero-Copy Accounts realloc in Anchor remaining_accounts Custom Account Types CU & Size Optimization Feature Flags & cfg Interacting with Native/Pinocchio Programs Advanced Anchor Best Practices

Tokens, NFTs & Standards

The SPL Token Program SPL Token Basics Associated Token Accounts (ATAs)Minting & Burning Transfers & Delegates Authorities Decimals & Amounts Wrapped SOL SPL Token in Programs SPL Token Best Practices

Token-2022 In Depth Token-2022 Basics Transfer Fees Transfer Hooks Confidential Transfers Metadata & Metadata Pointer Permanent Delegate & Non-Transferable Interest-Bearing & Default Account State Migrating from SPL Token Token-2022 Best Practices

NFTs & Metaplex Blueprint NFT Basics on Solana Metaplex Core Token Metadata Collections & Verification Candy Machine Royalties & Enforcement Metadata & Storage Reading NFTs (DAS API)NFT Best Practices

Compressed NFTs Explained State Compression Basics How Compression Works Compressed NFTs (Bubblegum)Reading Compressed Assets (DAS)Transferring cNFTs Cost & Trade-offs Compression Best Practices

Frontend & Clients

@solana/kit In Detail @solana/kit Basics RPC & Subscriptions Keypairs & Signers Building Transaction Messages Signing & Sending Codecs & Serialization Address Lookup Tables Migrating from web3.js v1 @solana/kit Best Practices

Wallet Integration Key Points Wallet Basics Wallet Adapter @wallet-ui/react Connecting & Disconnecting Signing Transactions & Messages Autoconnect & Session UX Hardware & Mobile Wallets Wallet Integration Best Practices

Typed Clients Blueprint Typed Clients Basics The Anchor TS Client Codama gill Fetching & Decoding Accounts Building Instructions Keeping Clients in Sync Typed Clients Best Practices

Next.js dApp Integration dApp Integration Basics Providers & App Router Server-Side Reads Client-Side Signing Displaying On-Chain Data Transaction UX API Routes for Transactions Caching & Realtime dApp Integration Best Practices

Solana Pay, Actions & Blinks Solana Pay Basics Transaction Requests Actions (the spec)Blinks Building an Action Security & Verification Solana Pay & Actions Best Practices

Solana Mobile In Depth Solana Mobile Basics Mobile Wallet Adapter (MWA)Building a Mobile dApp Deep Links & Session Handling The dApp Store Seed Vault & Security Solana Mobile Best Practices

DeFi, Security & Testing

DeFi Integrations Blueprint DeFi Basics on Solana Swaps with Jupiter AMMs (Raydium, Orca, Meteora)Perps & Order Books Lending & Borrowing Liquid Staking (LSTs)Jito & MEV Oracles DeFi Integrations Best Practices

Program Security Key Points Security Basics Signer & Owner Checks Account Validation Attacks PDA & Seed Attacks Arithmetic & Overflow Reinitialization Attacks CPI & Reentrancy Risks Sealevel Attacks Catalog Audit Workflow Security Best Practices

Testing Solana Programs Testing Basics LiteSVM Mollusk Bankrun (TS)Anchor TS Tests Fuzzing Programs Testing CPIs & PDAs Testing Against a Validator Testing Best Practices

Deployment & Upgrades In Detail Deployment Basics Deploying Programs Program Upgrades Verifiable Builds (solana-verify)Making Programs Immutable Governance-Gated Upgrades Rollbacks & Incident Response Deployment Best Practices

Validator Ops Explained Validator Basics Agave Client Firedancer / Frankendancer Jito-Solana Hardware & Networking Vote Accounts & Staking Stake-Weighted QoS (SWQoS)Monitoring & Epoch Ops Validator Best Practices

Ecosystem & Team

Python for Solana Python for Solana Basics solders & solana-py Building Transactions in Python AnchorPy Reading Chain Data Trading & Bots Data Analysis Python for Solana Best Practices

Essential Crates solana-program & solana-sdk anchor-lang & anchor-spl spl-token & spl-associated-token-account borsh & bytemuck mpl-core & mpl-token-metadata pinocchio & steel @solana/kit, Codama & gill (JS/TS)litesvm, mollusk & solana-bankrun Essential Libraries Best Practices

Team Onboarding Key Points Onboarding Devs Checklist Environment Setup Checklist The Solana Mental-Model Ramp First Program & dApp Code Review Guidelines Team Best Practices

Tech-Lead Craft

Incident Response In Depth Debugging Failed Transactions Transactions Not Landing RPC & Infrastructure Outages On-Chain Incident Response Blameless Post-Mortems & RCA Rollback & Mitigation Prevention Checklists

Enterprise Delivery Blueprint Devnet to Mainnet Promotion Program Upgrade Strategy Feature Flags & Progressive Rollout Rollback & Forward-Fix DORA Metrics for Web3 Frontend Release Management Delivery Best Practices

Technical Leadership In Detail Technical Decision-Making Architecture Decision Records (ADRs)Running Design Reviews Code Review Culture Mentoring & Leveling Delegation & Spreading Context Handling Technical Disagreements Leadership Best Practices

Stakeholder Collaboration Key Points Requirements to Technical Specs Prioritizing Platform & Tech Debt Estimation & Risk Roadmap Contributions Stakeholder Communication Making the Process Work (Scrum/Kanban/SAFe)Product Collaboration Best Practices

Case Studies Blueprint Reference: A DeFi Program + dApp Reference: An SPL Token Launch Reference: A Compressed-NFT Mint at Scale Before/After: Optimizing a Program for CU & Rent Before/After: Making Transactions Land Reliably Security Incident Retrospectives Lessons-Learned Catalog

Standards & Future-Proofing Coding & Program Standards Documentation Conventions Contribution Guidelines Dependency & Crate Governance Audit & Bug-Bounty Program Tracking Ecosystem Change Spikes, PoCs & Adopting New Tools Governance Best Practices

More

Conceptos básicos de Anchor

Noções Básicas de Anchor

/

/

© 2026 @csjcode|SystemsArchitect.io: Cloud Systems Tools|Terms

An independent, unofficial educational resource. Not affiliated with, endorsed, or sponsored by the brand/trademark maintainers/owners.

Search Documentation

Search across all documentation pages

Solana SME/Tags/Code Review

#Code Review3 pages

Pages tagged Code Review across 2 sections.

Code Review Guidelines Team Onboarding Key Points

Tech Leadership

Code Review Culture

Related tags

Rust Team Onboarding