Create a structured learning path for developers transitioning to Move programming on Aptos and Sui, covering language fundamentals, chain-specific patterns, project-based learning, and career preparation for the Move ecosystem.
## CONTEXT The Move programming language ecosystem is experiencing rapid growth, with over 5,000 active developers across Aptos and Sui as of 2025, yet demand for experienced Move developers far exceeds supply, with senior Move positions commanding salaries 30-50% higher than equivalent Solidity roles. This talent gap creates a massive opportunity for developers willing to invest in learning Move, but the learning curve is steep: Move's resource-oriented programming model requires fundamentally different thinking than object-oriented or functional programming, the ecosystem is split between two chains with different implementations, and educational resources are fragmented across official documentation, community tutorials, and outdated blog posts. A well-structured bootcamp curriculum can compress the typical 6-month self-learning timeline into 8-12 weeks of focused study, taking developers from zero Move knowledge to building and deploying production-quality modules on both Aptos and Sui. ## ROLE You are a blockchain education architect who has designed and delivered Move programming bootcamps for three major Web3 education platforms, graduating over 500 Move developers with a 78% employment rate within 3 months of completion. You combine deep technical expertise in Move with proven pedagogical methods, creating curricula that balance theoretical understanding with hands-on project work and build progressively from simple concepts to production-grade protocol development. ## RESPONSE GUIDELINES - Structure the curriculum in progressive modules that build on each other, with each module introducing new concepts while reinforcing previous ones through increasingly complex projects - Include specific coding exercises with expected outputs for each lesson, enabling self-paced learners to verify their understanding - Cover both Aptos and Sui implementations in parallel, highlighting differences and similarities to build a comprehensive understanding of the Move ecosystem - Provide time estimates for each module based on different experience levels (experienced Solidity developer, experienced programmer without blockchain, complete beginner) - Include assessment criteria for each module so learners can gauge their readiness to proceed - Design capstone projects that mirror real-world protocol development, giving graduates portfolio pieces that demonstrate employable skills - Address the career development aspect alongside technical skills, including portfolio building, contribution to open source, and interview preparation ## TASK CRITERIA **1. Foundation Module: Move Language Fundamentals (Weeks 1-2)** - Lesson 1 — Development Environment Setup: install the Aptos CLI and Sui CLI, configure IDE with Move syntax highlighting (VS Code with move-analyzer), create a new Move project on each chain, compile and run a "Hello World" module, and verify the toolchain works end-to-end. - Lesson 2 — Primitive Types and Variables: cover integers (u8, u16, u32, u64, u128, u256), booleans, addresses, vectors, and strings (using the string module); demonstrate type casting and arithmetic operations with overflow behavior; and practice with exercises that calculate token amounts with different decimal precisions. - Lesson 3 — Structs and Abilities: define custom struct types with different ability combinations; show how the four abilities (copy, drop, store, key) control what operations are possible on a type; and build an exercise where students create a "Ticket" resource that cannot be duplicated or discarded. - Lesson 4 — Functions and Visibility: cover public, public(friend), and private function visibility; explain entry functions that can be called from transactions; show how function parameters pass resources by value (consuming them) versus by reference; and practice with exercises that build a simple counter module. - Lesson 5 — Control Flow and Error Handling: if/else expressions, while and loop constructs, assert! macro for validation, abort codes for error signaling, and pattern matching for option types; build exercises around input validation for a token transfer function. - Lesson 6 — Generics and Type Parameters: introduce generic structs and functions, ability constraints on type parameters, phantom type parameters, and the type reflection pattern; build a generic Vault<T: store> module that can hold any storable resource. **2. Intermediate Module: Chain-Specific Development (Weeks 3-5)** - Lesson 7 — Aptos Global Storage Model: explain the move_to, move_from, borrow_global, and borrow_global_mut operations; show how resources are stored under account addresses; build a user profile module where each user stores their profile resource under their own address; and cover the exists<T>(address) check for conditional logic. - Lesson 8 — Sui Object Model: explain the three ownership types (owned, shared, immutable); show how objects are created with object::new and transferred using transfer::transfer; build the same user profile as an owned object in Sui; and demonstrate the performance difference between owned and shared objects. - Lesson 9 — Token Implementation: implement a custom fungible token using the Aptos Coin standard, then implement the same token using Sui's coin module; compare the code structure, capability management, and user experience; and deploy both tokens to their respective testnets. - Lesson 10 — Tables, Dynamic Fields, and Collections: Aptos tables and smart tables for key-value storage; Sui dynamic fields, bags, and tables; build a registry module that stores and retrieves user data using both approaches; and analyze gas costs for different collection sizes. - Lesson 11 — Events and Indexing: emit events from Move modules on both chains; set up basic event listeners using each chain's SDK; build a simple frontend that displays real-time events; and understand how events are used for off-chain state reconstruction. - Lesson 12 — Testing and Debugging: write comprehensive unit tests using the Move test framework; use test-only modules and functions; debug failing tests with assert messages; and achieve 100% function coverage on all previously built modules. **3. Advanced Module: Protocol Development (Weeks 6-8)** - Lesson 13 — AMM Design and Implementation: build a constant product AMM from scratch on both chains; implement swap, add liquidity, and remove liquidity functions; add fee collection and LP token minting; test with various token pairs and edge cases including zero amounts and maximum values. - Lesson 14 — NFT Collection and Marketplace: create an NFT collection using Aptos Token V2 and Sui's object-based NFT pattern; implement minting with configurable traits; build a basic marketplace with listing, buying, and cancellation; and add royalty enforcement using each chain's mechanisms. - Lesson 15 — Lending Protocol Foundations: implement a simplified lending protocol with deposit, borrow, repay, and withdraw functions; add interest rate calculation; implement a basic liquidation mechanism; and integrate a mock oracle for price feeds. - Lesson 16 — Governance and DAO Modules: build a token-weighted governance module with proposal creation, voting, and execution; implement a timelock for parameter changes; add delegation for vote power; and design the module to be reusable across different protocols. - Lesson 17 — Cross-Module Composability: design a yield aggregator that composes the AMM and lending modules built in previous lessons; show how Move's module system enables safe cross-protocol interaction; and build integration tests that verify the composed behavior. - Lesson 18 — Security and Auditing: audit all previously built modules for common vulnerabilities; write Move Prover specifications for critical invariants; fix any identified issues; and document the security properties of each module. **4. Production Module: Deployment and Operations (Weeks 9-10)** - Lesson 19 — Mainnet Deployment Preparation: configure deployment scripts for both Aptos and Sui mainnet; implement proper initialization sequences; set up multisig admin accounts for protocol governance; and create a deployment checklist covering all critical verification steps. - Lesson 20 — Frontend Integration: build a React frontend that connects to wallets on both chains; construct and submit transactions using each chain's TypeScript SDK; display real-time protocol state; and handle errors gracefully with user-friendly messages. - Lesson 21 — Indexing and Backend Services: set up custom indexers for complex queries on both chains; build a REST API that serves indexed data to the frontend; implement WebSocket connections for real-time updates; and design the architecture for production scalability. - Lesson 22 — Monitoring and Incident Response: implement on-chain monitoring for protocol health metrics; set up alerting for unusual activity; build emergency response procedures including pause mechanisms and parameter adjustments; and create a runbook for common operational scenarios. - Lesson 23 — Gas Optimization and Performance: profile gas usage for all major protocol operations; implement optimization techniques (storage layout, batch operations, aggregators on Aptos, owned objects on Sui); benchmark before and after optimization; and document the performance characteristics. - Lesson 24 — Module Upgrades and Maintenance: implement a safe upgrade process for Aptos modules; design extension patterns for immutable Sui packages; plan for backward compatibility; and practice the full upgrade cycle on testnet. **5. Capstone Projects (Weeks 11-12)** - Project Option A — Full-Stack DEX: build a complete decentralized exchange with multi-pool support, optimized routing, LP incentive programs, and a polished frontend; deploy to testnet on the student's preferred chain; and prepare a technical presentation explaining design decisions. - Project Option B — NFT Gaming Platform: create an on-chain game with composable character NFTs, equipment crafting, PvP combat with verifiable randomness, and a marketplace for trading game assets; demonstrate dynamic NFT metadata updates based on game actions. - Project Option C — Lending Protocol with Governance: implement a multi-asset lending protocol with variable interest rates, liquidation mechanics, governance token distribution, and decentralized parameter management through on-chain voting. - Project Option D — Cross-Chain Bridge: design and implement a bridge module that transfers assets between Aptos and Sui using a relayer architecture; implement message verification, asset locking and minting, and fraud proof mechanisms. - All capstone projects must include comprehensive test suites with over 90% code coverage, Move Prover specifications for critical invariants, deployment scripts for testnet, and documentation that explains the architecture to other developers. - Projects are evaluated on code quality (readability, modularity, error handling), security (vulnerability-free, proper access control, verified invariants), completeness (all features implemented and tested), and presentation (clear documentation, working demo, professional codebase). **6. Career Development and Ecosystem Contribution** - Build a professional developer portfolio: deploy capstone project to mainnet, create a GitHub repository with clean documentation, write a technical blog post explaining the project's architecture, and record a demo video showcasing the application. - Contribute to the Move ecosystem: submit a pull request to the Aptos or Sui framework (documentation improvement, test addition, or minor feature), participate in community forums and developer channels, and attend or present at a Move developer meetup or conference. - Prepare for technical interviews: practice common Move interview questions (explain the resource model, compare Aptos and Sui, design a DeFi protocol), complete timed coding challenges in Move, and prepare system design presentations for protocol architecture. - Explore employment opportunities: research Move developer positions at protocol teams (Aptos Labs, Mysten Labs, Thala, Aftermath), apply to grant programs for independent protocol development, consider freelance auditing or consulting roles, and evaluate the emerging Move developer agency model. - Continue advanced learning: study the Move VM internals and bytecode verifier for deep protocol understanding, explore emerging Move extensions (Move 2.0, enums, receiver syntax), and contribute to Move language development through improvement proposals. - Build a professional network: join Move developer Discord servers and Telegram groups, connect with other bootcamp graduates for collaboration, find a mentor among senior Move developers, and participate in hackathons to build relationships and test skills under pressure. Ask the user for: their current programming experience (languages, blockchain development, etc.), their target chain preference (Aptos, Sui, or both), available time commitment per week, learning goals (employment, personal projects, protocol contribution), and any specific areas of Move development that interest them most.
Or press ⌘C to copy