Building on Solana as a Turbin3 Q3 Cohort Builder

Program: Turbin3 Q3 2026 Cohort
Capstone: Web3 project built with teammates from Russia and Finland
Tech Stack: Solana, Rust, Anchor, Web3

The Program: Hands-On Solana Development

Turbin3 is a builder-focused Solana program centered on shipping real on-chain software. As a Builder in the Q3 2026 cohort, my work is focused on hands-on Solana development — writing, deploying, and testing programs directly on Solana Devnet rather than staying at the level of tutorials and theory.

The cohort works through the core primitives of Solana program development:

• Rust — the language Solana programs are written in, with its ownership model and strict compile-time guarantees.
• Anchor — the framework that handles account validation, serialization, and instruction routing so you can focus on program logic.
• PDAs (Program Derived Addresses) — deterministic, program-owned accounts that enable stateless programs to manage data and sign for transactions.
• CPIs (Cross-Program Invocations) — composing with other on-chain programs, the foundation of Solana's composability.

The Capstone: A Web3 Project Across Three Countries

The centerpiece of the cohort is a capstone Web3 project, built toward deployment on Solana Devnet. I'm building it together with teammates based in Russia and Finland — a fully distributed team spanning three time zones.

Working across borders on an on-chain codebase has its own texture: program design decisions need to be written down precisely because you can't just tap someone on the shoulder, and every instruction interface has to be agreed on before anyone writes a line of Rust. The coordination overhead is real, but so is the payoff — you learn to design program architectures that are legible to people who've never seen the code before.

Skills

• Solana
• Rust (Programming Language)
• Anchor
• Web3

The Outcome & Learnings

The cohort is ongoing, with the capstone targeting Solana Devnet. The deepest learning so far is that Solana development inverts a lot of web2 instincts: state lives in accounts, not in the program; computation is metered; and composability through CPIs means your program is a building block for others from day one. Building with an international team has reinforced that clear interfaces and written design docs matter as much as the code itself.