60 Days of Rust + Solana Web3
Intensive Roadmap · Zero to Production Solana Infrastructure · Every Concept in Rust
Learn Rust from zero, then build production Solana Web3 infrastructure in 60 days. ~6-8 hrs/day. Ship code every single day. No shortcuts: Rust first, then Solana. Every Solana concept is taught in Rust, not TypeScript.
Rust Foundations
Build an unshakeable mental model of Rust before touching a single line of Solana. Ownership, borrowing, lifetimes, traits, iterators, and concurrency - all learned the hard way by writing real programs. By Day 10 you ship a full CLI tool with tests, serialization, and a GitHub release.
Week-by-Week Plan
Setup, Syntax & Control Flow
Install Rust via rustup, configure VS Code with rust-analyzer. Variables, mutability, shadowing, scalar types, tuples, arrays. Functions, if, loop, while, for, ranges. Read: TRPL Chapters 1-3. Build: Hello World -> FizzBuzz -> number guessing game.
Ownership, Borrowing & Slices
Ownership rules, move semantics, stack vs heap. Immutable &T and mutable &mut T references, borrowing rules. &str vs String, array slices &[T]. Read: TRPL Chapter 4. Build: first_word() function; deliberately trigger and fix borrow checker errors. Checkpoint: Explain ownership out loud without notes.
Structs, Enums & Pattern Matching
Structs, impl blocks, methods, ::new() constructors. Enums with data, Option<T>, match, if let, while let. Modules: mod, use, pub. Read: TRPL Chapters 5-7. Build: Model a card game with structs + enums; coin sorter with match.
Collections, Error Handling & Generics
Vec<T>, String, HashMap<K,V>, entry API. panic! vs Result<T,E>, the ? operator. Generic functions/structs, trait bounds, where clauses, impl Trait. Derive macros: Debug, Clone, PartialEq, Display. Read: TRPL Chapters 8-10.2. Build: Word frequency counter; CSV parser with full error propagation; generic stack.
Lifetimes, Iterators & Closures
Lifetime annotations 'a, elision rules, 'static. Closures: Fn, FnMut, FnOnce, move closures. Iterator adapters: map, filter, fold, collect; lazy evaluation. Read: TRPL Chapters 10.3-13.2. Build: Memoization cache; full iterator pipeline over a dataset.
Testing
Unit tests #[test], integration tests in tests/, #[cfg(test)]. assert!, assert_eq!, #[should_panic], Result in tests. Property-based testing with proptest. Build: 20 tests for collections and iterator code; property tests for a sorting function.
Smart Pointers & Concurrency
Box<T>, Rc<T>, RefCell<T>, Arc<T>, Mutex<T>, RwLock<T>. Deref, Drop, RAII pattern. thread::spawn, join(), mpsc channels, Arc<Mutex<T>>. Send and Sync marker traits. Read: TRPL Chapters 15-16. Build: Thread-safe counter; producer-consumer pipeline with channels.
Trait Objects, Unsafe & Macros
dyn Trait vs impl Trait, fat pointers, vtables, object safety. Box<dyn Trait> patterns, plugin system design. unsafe raw pointers, extern C FFI basics. Declarative macros macro_rules!. Read: TRPL Chapters 17-19. Build: Plugin system with Box<dyn Trait>; simple vec!-style macro.
Serialization with borsh & serde
Why serialization matters for on-chain programs. serde + serde_json for off-chain data. borsh - binary serialization used by Solana programs. bytemuck for zero-copy casting. Build: Serialize/deserialize a custom account struct with borsh; benchmark vs serde_json. Checkpoint: Borsh is Solana's encoding - understand it cold.
Milestone - CLI Task Manager
Combine all Phase 1 knowledge. Cargo workspaces, cargo doc, release profiles. Read: TRPL Chapter 14; Programming Rust Chapters 1-5. Build: CLI Task Manager - clap for args, borsh + serde_json for persistence, Result everywhere, 20+ tests, pushed to GitHub.
Resources4
Primary reference for Days 1-10. Read Chapters 1-14 cover to cover.
Deeper treatment of Rust internals and systems context. Days 5-15.
Best YouTube channel for Rust beginner to intermediate. Follow along as you read TRPL.
Full Rust toolchain. Install everything Day 1 and never uninstall.
Projects
- →CLI Task Manager (Day 10): clap for args, borsh + serde_json for persistence, Result everywhere, 20+ tests, pushed to GitHub
Can explain ownership and borrowing without notes. Comfortable with generics, traits, and iterators. borsh serialization understood cold. CLI Task Manager shipped with 20+ tests.
Intermediate & Async Rust
Push into the parts of Rust that separate good engineers from great ones: advanced traits and generics, lock-free concurrency, async/await internals, and production-grade error handling. Phase 2 ends with you building a real async library that talks to Solana's RPC - your first taste of the ecosystem.
Week-by-Week Plan
Advanced Traits & Generics
Associated types, operator overloading (std::ops), newtype pattern. Higher-ranked trait bounds (HRTBs): for<'a> Fn(&'a T). PhantomData<T>, variance: covariance vs contravariance. Read: Programming Rust Ch 11-13; Rust for Rustaceans Ch 1-3. Build: Generic cache with lifetime constraints; PhantomData marker type examples.
Advanced Iterators & Functional Patterns
Implementing Iterator from scratch. IntoIterator, FromIterator, DoubleEndedIterator. Combinators: scan, flat_map, take_while, peekable. Read: Programming Rust Ch 15. Build: Custom streaming iterator; implement collect() into a custom collection.
Concurrency Deep Dive
Lock-free data structures: atomics, AtomicUsize, Ordering. Rayon for data parallelism, work-stealing scheduler. crossbeam: scoped threads, SegQueue, channel. Read: Rust Atomics and Locks Ch 1-5. Build: Parallel batch processor with Rayon; lock-free MPSC queue from scratch.
Async Rust Foundations
The async/await model, Future trait internals, wakers. Tokio runtime: #[tokio::main], tasks, spawn. join!, select!, tokio::time, CancellationToken. Tokio sync primitives: mpsc, broadcast, watch, Semaphore. Read: Rust for Rustaceans Ch 8-9; Tokio tutorial. Build: Async echo server; concurrent HTTP fetcher with reqwest.
Error Handling at Scale
thiserror for library errors, anyhow for application errors. Error wrapping, context chains, backtraces. Designing error hierarchies for large Rust projects. Read: Zero to Production Ch 1-3. Build: Refactor CLI Task Manager with thiserror; add anyhow to binary entry points.
Performance & Profiling
Zero-cost abstractions in practice. cargo bench, Criterion benchmarking crate. flamegraph, cargo-flamegraph, allocation profiling with heaptrack. SIMD basics with std::arch. Read: Rust Performance Book Ch 1-5. Build: Profile the CLI Task Manager; Criterion benchmarks; reduce allocations in hot paths.
Async HTTP Server with Axum
Axum routing, extractors, middleware, shared state. JSON with serde, query/path params, error handling in handlers. Tower service model, graceful shutdown, tracing for structured logs. Build: REST API with CRUD, auth middleware, health check, request tracing.
Milestone - Async Solana RPC Client Library
Combine async Rust + HTTP/WebSocket knowledge. solana-client crate: RpcClient, nonblocking::RpcClient. Batched RPC requests, retry with exponential backoff, rate limiting. Build: Async Solana RPC Client Library - connection pooling, batching, websocket subscriptions, full test suite.
Resources5
The definitive book on idiomatic, advanced Rust. Required reading Days 12-18.
Free online. The only book that explains Rust concurrency primitives from first principles.
Official async runtime tutorial. Do every exercise. Essential for Day 14.
Long-form streams building real Rust projects. Watch alongside Rust for Rustaceans.
Excellent deep-dive videos on Rust internals, async, and systems concepts.
Projects
- →Async Solana RPC Client Library (Day 18): connection pooling, batching, websocket subscriptions, full test suite
Comfortable with HRTBs, PhantomData, async/await internals. Can build and profile async Rust services. thiserror + anyhow error hierarchy understood. Async RPC library compiles, tests pass, handles backoff and retries.
Solana Architecture & Native Programs
Understand Solana from the validator's perspective before writing a single program. PoH, Tower BFT, Turbine, Gulf Stream, Sealevel - each one makes Solana what it is. Then build native programs without Anchor, so you understand exactly what Anchor is abstracting. Phase 3 ends with a complete CLI wallet that talks to the real chain.
Week-by-Week Plan
Solana's Architecture
Proof of History (PoH): VDF chain, ordering without coordination. Tower BFT: vote lockouts, fork choice, finality. Turbine: shred-based block propagation, erasure coding. Gulf Stream: mempool-less forwarding to upcoming leaders. Sealevel: parallel transaction execution, account access lists. Read: Solana Whitepaper; SolDev Module 1. Build: Visualize the PoH chain; query leader schedule via RPC in Rust.
The Account Model
Everything is an account: programs, data, system, native programs. Account anatomy: key, lamports, data, owner, executable, rent_epoch. Rent: rent-exempt minimum, reclaiming accounts by closing them. System Program: create_account, transfer, assign, allocate. Read: SolDev Module 2; Solana Cookbook - Accounts. Build: Script to create accounts, check rent-exemption, verify ownership in Rust. Checkpoint: Draw the full account model from memory.
PDAs & Cross-Program Invocations
Program Derived Addresses: find_program_address, bump seeds, canonical bumps. Why PDAs have no private key - and why that enables trustless programs. CPI: invoke and invoke_signed, depth limits (4), reentrancy protection. Return data: set_return_data / get_return_data. Build: Derive PDAs for a vault pattern; write a program that CPIs to System Program.
Transactions & the Runtime
Transaction structure: message, signatures, versioned transactions (v0). Address Lookup Tables (ALTs): packing more accounts per transaction. Compute units: budget, ComputeBudgetInstruction, sol_log_compute_units. Commitment levels: processed, confirmed, finalized. Build: Multi-instruction transaction with ALT in Rust; measure compute unit consumption.
Writing Native Solana Programs
Entry point: entrypoint!, process_instruction. AccountInfo: reading data, checking owners, verifying signers. borsh for account (de)serialization, ProgramError, custom errors. msg! for logging, sol_log_pubkey. Read: Solana Docs - Programming Model. Build: Native counter program - initialize, increment, decrement; deploy to localnet.
Native Program Patterns
Discriminators: how to identify instruction type without Anchor. State machines: encoding program state in account data. Authority patterns: owner checks, delegate patterns. Handling multiple instructions in one entry point cleanly. Build: Native escrow program - deposit, release, cancel; full solana-program-test suite.
SPL Token Program
Token Program vs Token-2022 (Token Extensions). Mint accounts, token accounts, associated token accounts (ATAs). mint_to, transfer, burn, approve, freeze, close_account. CPI to Token Program from your own program. Build: Rust client - create mint, ATA, mint tokens, transfer, burn; CPI token transfer in a program.
Token-2022 & Metaplex
Token Extensions: transfer fees, interest-bearing, confidential transfers, TransferHook. Metaplex Token Metadata: create_metadata_accounts_v3, master editions. NFTs on Solana: minting, burning, collection verification. cNFTs (compressed NFTs): Merkle trees, Bubblegum program, DAS API. Build: Token-2022 mint with transfer fee; mint a cNFT collection via Bubblegum.
Solana Clients & WebSocket Subscriptions
RpcClient vs nonblocking::RpcClient in depth. getProgramAccounts with memcmp and dataSize filters. WebSocket: accountSubscribe, logsSubscribe, slotSubscribe. Helius enhanced WebSocket: parsed transaction notifications. Build: Real-time token transfer monitor - subscribe to a mint's logs, decode and display.
Milestone - CLI Wallet + Chain Explorer
Combine all Phase 3 knowledge. Build: CLI Wallet + Chain Explorer - clap CLI: generate keypair, check balance, send SOL, decode any transaction, display token balances, watch address for incoming transfers in real time.
Resources7
Official reference throughout Phases 3-5. The programming model section is essential.
Best free structured Solana curriculum. Use Modules 1-4 for Days 19-28.
Practical Solana development videos. Good companion to SolDev course.
Official channel. Breakpoint talks are excellent for architecture understanding.
Local validator, keypair management, deploys. Install Day 19 alongside solana-test-validator.
Projects
- →Native counter program deployed to localnet (Day 23)
- →Native escrow program with full solana-program-test suite (Day 24)
- →CLI Wallet + Chain Explorer (Day 28): keypair gen, send SOL, decode txns, watch addresses live
Can explain PoH, Tower BFT, and Sealevel from memory. Account model understood cold. Can write, deploy, and test a native Solana program without Anchor. CLI Wallet ships and works on devnet.
Anchor Framework & DeFi Protocols
Anchor accelerates Solana program development by generating boilerplate, IDLs, and enforcing account validation patterns. But you already understand what Anchor is doing - because you built native programs first. Phase 4 applies that knowledge to DeFi: AMMs, lending, oracles, MEV, and security auditing.
Week-by-Week Plan
Anchor Foundations
Why Anchor: IDL generation, account validation macros, discriminators. #[program], #[derive(Accounts)], Context<T>, #[account] struct. Constraints: init, payer, space, mut, seeds, bump, close, realloc. Read: Anchor Book Chapters 1-5. Build: Rewrite counter + escrow in Anchor; compare generated IDL vs native.
Anchor CPIs & Advanced Accounts
CpiContext::new and CpiContext::new_with_signer for PDA-signed CPIs. Account<'info, T>, Signer<'info>, SystemAccount, UncheckedAccount. init_if_needed, zero-copy accounts #[account(zero_copy)], bytemuck. Build: Staking program - stake tokens (CPI to Token Program), track rewards in PDA.
Anchor Testing: Bankrun & Trident
anchor test: mocha runner, AnchorProvider, typed Program<IDL>. BankrunProvider: fast, deterministic, no validator needed. Test patterns: beforeEach, account state assertions, error matching, time warp. trident: coverage-guided fuzzer for Anchor programs. Build: 30+ test suite for staking program; fuzz with trident.
AMMs on Solana
Orca Whirlpools (CLMM): tick arrays, liquidity, sqrt price math. Raydium CLMM architecture and differences. Reading pool state in Rust: deserializing Whirlpool accounts. Swapping via CPI: routing through AMM programs. Build: Rust client - fetch Orca Whirlpool price, simulate swap, execute on devnet.
Lending, Oracles & Flash Loans
MarginFi architecture: banks, marginfi accounts, health factor. Pyth oracle: pull-based PriceFeed accounts, confidence intervals, staleness checks. Switchboard: on-demand custom feeds. Flash loans on Solana: same-transaction atomicity. Build: Program that reads Pyth price and enforces price bounds; MarginFi deposit/borrow via client.
Smart Contract Security
Signer verification: missing check attacks. Owner checks: fake account substitution. PDA bump canonicalization exploits. Arithmetic overflow: checked_add, saturating_mul. Re-initialization, type cosplay, account data matching. Read: Sealevel Attacks repo. Build: Exploit and fix all 9 Sealevel attack examples; audit your staking program.
Governance & DAOs
SPL Governance: realms, councils, proposals, voting lifecycle. Squads Protocol: multisig, vault_transaction, config_transaction. Program upgrade via Squads: time-locked, multi-sig controlled deploys. Build: Squads multisig on devnet; SOL transfer proposal; approve and execute.
MEV & Transaction Landing
Solana MEV: no public mempool, leader-based ordering, Jito. Priority fees: ComputeBudgetInstruction::set_compute_unit_price, dynamic estimation. Jito bundles: block engine API, tip accounts, simulateBundle. Jito searcher SDK in Rust: subscribing to mempool notifications. Build: Transaction Engine - smart priority fee estimator, Jito bundle submission, simulation before send, confirmation tracker.
Solana Pay & Blinks
Solana Actions spec: GET/POST API, transaction serialization. Blinks: embedding Solana actions in any URL. Building an Actions API server with Axum in Rust. Build: Actions API Server - swap action, tip jar action, NFT mint action; registered as a Blink.
Milestone - Full On-Chain DeFi Protocol
Combine all Phase 4 knowledge. Build: Minimal AMM + Lending Protocol - liquidity pools, swap, deposit collateral, borrow, liquidation, Pyth oracle integration, full Anchor test suite (unit + fuzz + invariant), deployed to devnet.
Resources7
Official Anchor documentation. Read Chapters 1-5 Day 29, reference rest as needed.
9 common Solana smart contract vulnerabilities with exploits and fixes. Required Day 34.
DeFi-focused modules covering Anchor deeply. Use alongside the Anchor Book.
Solana program patterns and security videos. Watch Day 34 series on exploits.
Install via avm. Run anchor build, anchor test, anchor deploy throughout Phase 4.
Deterministic, validator-free testing. Replaces solana-test-validator in most test scenarios.
Coverage-guided fuzzing for Anchor programs. Use Day 31 and then re-run on Day 38 protocol.
Projects
- →Staking program with full Bankrun + trident fuzz suite (Day 31)
- →Transaction Engine with Jito bundle submission and priority fee estimation (Day 36)
- →Blinks / Actions API Server in Axum (Day 37)
- →Full On-Chain DeFi Protocol: AMM + Lending with Pyth, deployed to devnet (Day 38)
Anchor constraints and CPIs understood without looking at docs. Can audit a program for Sealevel vulnerabilities. Jito bundle flow understood end-to-end. Minimal AMM + lending protocol live on devnet with fuzz-tested suite.
Solana Infrastructure Engineering
This is where you become a Solana infrastructure engineer, not just a program developer. Geyser plugins, custom indexers, MEV bots, RPC gateways, cross-chain bridges, ZK proof verification, and full Kubernetes deployments. Phase 5 ends with a production-grade infrastructure platform that runs all your services together.
Week-by-Week Plan
Geyser Plugin Interface
What Geyser is: the validator's internal streaming API. Plugin lifecycle: on_account_update, on_transaction, on_slot_status_update. Filtering: which programs/accounts to track. Yellowstone Geyser gRPC (Helius/Triton): high-throughput streaming. Build: Subscribe to Yellowstone gRPC; stream all token transfers in real time to stdout.
Writing a Custom Geyser Plugin
Geyser plugin in Rust: GeyserPlugin trait, dynamic loading. Deserializing Anchor account data from raw bytes using the IDL. Output targets: Kafka topic, PostgreSQL table, Redis pub/sub. Build: Custom Geyser plugin for your AMM - filter swap events and publish to Kafka.
Solana Indexing Pipeline
Full pipeline: Geyser -> Kafka -> consumer -> PostgreSQL. Handling reorgs (forks): rollback strategies, confirmed vs finalized. getProgramAccounts polling fallback for missed events. Apache Arrow + Parquet for historical data warehousing. Build: Full indexer for the AMM program - all state changes to Postgres + Parquet export.
Helius DAS API & Webhooks
Digital Asset Standard (DAS): getAsset, getAssetsByOwner, searchAssets. cNFT queries: compressed NFT ownership, collection membership. Helius webhooks: createWebhook, transaction types, enhanced transaction parsing. Build: Wallet portfolio tracker - all SPL tokens, NFTs, cNFTs via DAS; webhook alert on incoming transfers.
High-Performance RPC Gateway
Load balancing across multiple RPC nodes (Helius, QuickNode, self-hosted). Response caching: finalized block data, static account data. WebSocket proxying for subscriptions. Rate limiting, auth, metrics with Prometheus. Build: Axum RPC Gateway - multi-backend round-robin, caching, rate limiting, WS proxy.
MEV Searcher Bot
Arb opportunity detection: price divergence between two Orca pools. Latency optimization: co-location, direct validator connections. Bundle construction: optimal tip calculation, simulation. Risk management: max loss per bundle, circuit breaker. Build: Rust Arb Bot - monitor two pools, detect divergence, build Jito bundle, simulate, submit.
Validator Operations
Validator hardware requirements and tuning. solana-validator setup: identity, vote keypair, ledger, accounts DB. Snapshot management: full vs incremental, account hash verification. solana-watchtower: slot lag alerts, vote credit monitoring. Build: Run a local validator with custom genesis; set up watchtower alerts.
Cross-Chain Infrastructure with Wormhole
Wormhole architecture: guardians, VAAs, relayers. Token Bridge: lock-and-mint across chains. Wormhole Connect SDK for cross-chain swaps. Build: Send a cross-chain message from Solana devnet to Ethereum Sepolia via Wormhole.
ZK on Solana
ZK proof verification on Solana: verify_proof syscall. Light Protocol: ZK compression for accounts and tokens. SP1 (Succinct) and Risc0: generating ZK proofs of Solana state. Build: Verify a Groth16 proof on-chain via Solana's ZK syscall.
Account Compression & State Scale
Concurrent Merkle trees: structure, proof generation, proof verification. Bubblegum: cNFT minting, transfer, burn at massive scale. Light Protocol: ZK-compressed accounts for cheap state. Build: Mint 100,000 cNFTs using concurrent Merkle trees; measure cost vs regular NFTs.
Firedancer & the SVM
Firedancer: Jump Crypto's validator in C - why it changes the game. Agave: Anza's fork of the Solana Labs validator client. SVM as a standalone execution environment: Eclipse, SoonSVM. svm-runner: run the SVM in tests without a full validator. Build: Run a Solana program against svm-runner; explore Firedancer dev build.
Monitoring & Observability
Prometheus metrics for: RPC latency, indexer throughput, tx success rate. Grafana dashboards: validator health, MEV bot P&L, indexer lag. OpenTelemetry distributed tracing across services. On-chain anomaly detection: large transfers, unusual program activity. Build: Full observability stack for all your services - dashboards + alerting rules.
Load Testing & Reliability
Load testing the RPC gateway: k6, wrk, drill. Transaction spam testing: saturate devnet, measure landing rate. Kubernetes: deployment manifests, HPA, resource limits. Build: K8s manifests for RPC gateway + indexer; load test to 10K RPS.
Milestone - Full Solana Infrastructure Platform
Combine all Phase 5 components. Build: Complete Solana Infrastructure Platform - Axum RPC gateway, Yellowstone Geyser indexer, Postgres + Parquet data warehouse, Jito arb bot, Prometheus + Grafana, Docker Compose, K8s manifests.
Resources4
Best managed Solana RPC with enhanced APIs. Use Yellowstone gRPC for Geyser streaming.
Alternative to Helius. Good for multi-provider redundancy in the RPC gateway.
Use in Phase 5 for cross-chain infrastructure work with Wormhole and Stylus.
Core Rust SDKs for Solana. Use throughout Phases 3-5 for all client-side code.
Projects
- →Axum RPC Gateway with multi-backend load balancing, caching, and rate limiting (Day 43)
- →Rust MEV Arb Bot with Jito bundle submission and circuit breaker (Day 44)
- →Full Solana Infrastructure Platform: Geyser indexer, Postgres, Jito bot, Prometheus + Grafana, K8s (Day 52)
Can write, build, and deploy a custom Geyser plugin. RPC gateway handles 10K RPS in load tests. Arb bot detects divergence and submits bundles. Full infrastructure platform runs in Docker Compose; K8s manifests apply cleanly.
Open Source & Portfolio
Finish strong. Contribute to real Solana Rust projects, polish every milestone repo, write technical benchmarks that prove your infrastructure numbers, and publish a portfolio that shows you can ship. Day 60 is the day you share publicly.
Week-by-Week Plan
Reading Real Codebases
Navigate: solana-labs/solana, coral-xyz/anchor, jito-foundation/jito-solana, anza-xyz/agave. How to find good first issues in the Solana ecosystem. PR etiquette, contribution guidelines, commit hygiene. Tasks: Fork one project; read a core module deeply; find an open issue.
Open Source PR
Submit a PR to a real Solana Rust project (Anchor, SPL, Jito, Yellowstone, Helius SDK). Add a test, fix a bug, improve docs with working code examples. Tasks: PR submitted; address review feedback; document the contribution.
Portfolio Polish
Clean up all 5 milestone projects on GitHub. READMEs: architecture diagrams, program IDs, deployment instructions. Record a short demo video for each project. Write a technical blog post about the Infrastructure Platform.
Benchmarking Write-up
Geyser indexer throughput vs polling getProgramAccounts. Jito bundle landing rate vs standard sendTransaction. Rust RPC gateway vs Node.js - latency, memory, throughput. Publish blog post with real numbers and charts.
System Design
Design a high-frequency Solana arb bot at scale: latency, co-location, capital efficiency. Multi-region RPC routing, leader-aware transaction submission. Data availability: BigTable, Parquet, Triton One archival nodes. Build: System design document with architecture diagram.
Explore Advanced Ecosystem
Stylus (Arbitrum): write EVM contracts in Rust - cross-chain angle. revm: pure Rust EVM - for cross-chain infrastructure. Neon EVM: EVM compatibility layer running on Solana's SVM. Solar: fast Solidity compiler in Rust. Tasks: Write a Stylus contract; compare SVM vs EVM execution models.
Final Preparations
GitHub profile: pinned repos, profile README, on-chain Solana address. Portfolio site live with program IDs and explorer links. All blog posts published (aim for 4+). Open source PRs merged or in review.
Milestone - Final Day
Final push to all repos. Write a reflection: what you built, what surprised you, what's next. Share portfolio publicly. Tasks: Portfolio link shared; reflection published; celebrate.
Resources4
Core validator client. Read the runtime and accounts-db modules for deep understanding.
Best place to submit a first Solana OSS contribution. Tests and docs are good entry points.
Jito's fork of the Solana validator. Read the bundle + MEV modules.
Projects
- →Open Source PR merged or in review on a real Solana Rust project (Day 54)
- →All 5 milestone repos polished with READMEs, diagrams, and demo videos (Day 55)
- →Benchmarking blog post with real Geyser vs polling and Jito vs sendTransaction numbers (Day 56)
- →Portfolio site live with all program IDs and Solana explorer links (Day 59)
At least one OSS PR submitted to the Solana ecosystem. All 5 milestone projects have clean READMEs and are publicly accessible. Benchmarking blog post published with real numbers. Portfolio site live. Reflection written and shared.