Skip to content
BR Academy

Smart Contract Development with Solidity: Zero to Deployed

Master Solidity from first contract to mainnet deployment. Build ERC-20/721 tokens, test with Foundry, optimize gas, ship verified contracts.

Beginner23 lessons7 hoursCertificate

About this course

You’ve written code in Python, JavaScript, or Go. Now you’re ready to build on Ethereum — but Solidity works differently, and most tutorials skip straight to copy-paste contracts without explaining why. This course closes that gap: production-ready smart contract development across 23 lessons, each built around a concept, a worked example, and a hands-on “Try it” exercise.

You’ll start in Solidity Foundations: syntax, types, and operators; the real gas-cost difference between storage, memory, and calldata; function visibility and modifiers; and events for off-chain indexing. From there you move into Object-Oriented Solidity — inheritance, interfaces, abstract contracts, libraries, and the custom-error patterns that save gas over require/revert strings.

The core of the course is Token Standards & OpenZeppelin: you’ll build an ERC-20 token from the raw spec before rebuilding it with OpenZeppelin’s audited library, then do the same for an ERC-721 NFT — from scratch first, OpenZeppelin second — so you understand what the library does for you, not just how to import it.

Testing & Gas Optimization covers Foundry and Hardhat side by side: writing tests, fixtures, coverage, and the profiling techniques used to find and fix expensive storage layouts. Storage packing, immutables, and targeted assembly tricks round out the module.

Deployment & Verification walks you through real testnet deploys, mainnet deployment and private-key management, and Etherscan verification — plus a pre-deployment security checklist covering the vulnerabilities auditors look for first. Advanced Patterns adds UUPS and transparent upgradeable proxies, role-based access control with OpenZeppelin’s AccessControl, and reentrancy prevention using checks-effects-interactions and guards.

The course closes with a Capstone Project: design, test, and deploy a custom ERC-20 token with minting, burning, and access control — a portfolio piece, not just a quiz.

This course is for developers with programming experience in any language who know the basics but have never shipped Solidity, and who need to go all the way to a verified mainnet contract. By the end you can write correct, gas-aware Solidity; design ERC-20/ERC-721 tokens from scratch and with OpenZeppelin; test with Foundry and Hardhat; optimize gas through storage packing and immutables; deploy and verify on mainnet while managing keys safely; implement upgradeable proxies; and audit your own code for reentrancy, overflow, and access-control bugs. Includes a certificate on completion.

What you will be able to do

  • Can write Solidity contracts using correct syntax, types, storage layouts, and state management
  • Can design and implement ERC-20 and ERC-721 tokens from scratch and using OpenZeppelin
  • Can test contracts with Foundry and Hardhat, including gas profiling and edge cases
  • Can optimize gas costs through storage packing, immutables, and assembly patterns
  • Can deploy contracts to testnets and mainnet, verify on Etherscan, and manage private keys safely
  • Can implement upgradeable proxies (UUPS and transparent) and understand the risks
  • Can audit your own code for common vulnerabilities (reentrancy, overflow, access control)

Curriculum 7 modules · 23 lessons

1Solidity Foundations4 lessons
  1. Solidity Syntax, Types, and Operators Preview15 min
  2. Storage vs Memory vs Calldata, Gas Implications 15 min
  3. Functions, Visibility, Modifiers, and State Changes 15 min
  4. Events, Indexed Parameters, and Off-Chain Indexing 15 min
2Object-Oriented Solidity3 lessons
  1. Inheritance, Interfaces, and Abstract Contracts 15 min
  2. Libraries, Using-For, and Code Reuse 15 min
  3. Custom Errors, Require/Assert/Revert, and Gas Savings 15 min
3Token Standards & OpenZeppelin4 lessons
  1. Build an ERC-20 Token from the Spec 20 min
  2. ERC-20 with OpenZeppelin, Extensions, and Minting 15 min
  3. Build an ERC-721 NFT from the Spec 20 min
  4. ERC-721 with OpenZeppelin, Metadata, and Enumeration 15 min
4Testing & Gas Optimization4 lessons
  1. Foundry Setup, Writing Tests, and Assertions 15 min
  2. Hardhat Testing, Fixtures, and Coverage 15 min
  3. Profiling Gas, Identifying Bottlenecks, and Optimization Patterns 20 min
  4. Storage Packing, Immutables, and Assembly Tricks 15 min
5Deployment & Verification4 lessons
  1. Deploying to Sepolia, Goerli, and Other Testnets 15 min
  2. Deploying to Mainnet, Managing Keys, and Transaction Costs 15 min
  3. Verifying Contracts on Etherscan and Block Explorers 15 min
  4. Pre-Deployment Audit, Common Vulnerabilities, and Best Practices 15 min
6Advanced Patterns3 lessons
  1. UUPS and Transparent Proxies, Storage Layout, and Risks 20 min
  2. Role-Based Access Control, OpenZeppelin AccessControl 15 min
  3. Reentrancy Attacks, Checks-Effects-Interactions, and Guards 15 min
7Capstone Project1 lesson
  1. Capstone: Deploy a Custom ERC-20 with Minting, Burning, and Access Control 70 min

Taught by Block Relations

Research & Education · Built for a developer (Python, JavaScript, Go, or similar background) who wants to build on Ethereum or EVM chains. You know programming basics but have never written Solidity. You need to deploy a contract to mainnet and verify it on Etherscan.

Contact us →