Last Updated : April 2025
Our instructors are industry experts with extensive experience in smart contract development and auditing. They are dedicated to helping you succeed through one-on-one mentorship, code reviews, and weekly live office hours.
Jeffrey Scholz, founder of RareSkills, was Yahoo’s youngest senior engineering manager, building its video machine learning team and earning two AI patents. His work at RareSkills has helped 100s of engineers land roles at top blockchain companies, and the author of the popular The RareSkills Book of ZK. He holds a Masters degree in computational theory from Columbia University.
Shung is a Smart Contract Auditor at Kebasec and an Associate Security Researcher at Spearbit, renowned for his expertise in blockchain security. He has previous experience as a protocol developer at Pangolin.
Other courses cram a bunch of topics to make their syllabus look impressive. Ours dwells on critical topics so you really master them.
Lectures keep “passive instruction” to a minimum. The instructor works through questions to drive student learning rather than read off of slides or do a “code-along” that would be better off as a recorded video. In lectures, we only “lecture” when teaching a subject that would take someone too long to figure it out on their own.
Our bootcamp has gone through over 5 iterations to maximize learning efficiency and focus on the topics that make a difference in learning. We understand the developer learning journey in web3 better than anyone else.
A lot of courses like to cram as many impressive-looking topics into a syllabus to create an impression that the student will learn a lot of material.
Obviously, it is not possible to “master” (in any sense of the word) 10 topics over the course of 10 weeks. In fact, if you spend so little time on a subject, you will probably just forget it the week after — and you net waste time!
Our heuristic for what to include is simple: build the underlying skills that enable developers to easily understand large production-level DeFi codebases.
Fundamentally, all DeFi protocols have:
If you master these three components, then you will be able to make sense of any DeFi protocol.
Let’s examine what the Tokens to DeFi course covers and see how they fit into this learning goal:
After teaching hundreds of developers, we’ve seen that some knowledge gaps in the Solidity language are surprisingly common. For example, we’ve seen a lot of developers don’t know the exact mechanics behind low-level calls and interface calls or how exactly try catch works. This part of the course focuses on aspects of Solidity that seem to not be covered well in existing online materials. If you have gaps in your understanding of Solidity, you will have a harder time reading production codebases and understanding how DeFi protocols work.
A good Solidity developer must be able to code an ERC-20 from scratch from memory and be fluent in creating fundamental token mechanisms such as tracking staking rewards, conducting an auction, or splitting up tokens among multiple parties. We’ve found that many Solidity devs take several minutes to write token routines that ought to be second nature. This part of the course ensures that token mechanics become second nature. Why? Tokens are everywhere in DeFi, even “token-like” mechanics recur frequently. However, not all tokens behave exactly the same way. It must be second nature for a developer to know how a token should behave and where there may be some variation in the behavior.
Math is fundamental to DeFi (finance and math go together!) but few learn how to use Solidity math properly. For example, one might compute the “average” of x, y, and z by computing (x + y + z) / 3, but this fails because the code will revert for some inputs (cases where x + y + z overflows). Similarly, how does one go about computing an exponent of Euler’s constant e (which appears in several financial formulas)? What is the difference between a fixed-point number and a Q-number? Students must master these subjects through repeated hands-on application as without knowing how math is done in Solidity, reading and writing production codebases in DeFi will be extremely challenging.
Any non-trivial DeFi application needs a way to track which depositors are owed what based on when they deposited and how much the protocol has gained or lost. It isn’t feasible to loop through each account and update each one. Optimizations that allow all accounts to be updated simultaneously have subtle gotchas that must be understood fully to develop safe code. Additionally, understanding vaults makes understanding rebase tokens (another common accounting mechanism) far easier. Almost every DeFi protocol has a vault or vault-like mechanism built in. If you don’t deeply understand vaults, you will struggle to read large codebases.
A flash loan is the simplest possible mechanism for traders to “use” the liquidity provided by investors. Therefore, we use this as the starting point for showing how liquidity is “used” and how profits ought to be distributed. We teach the ERC-3156, but also the way other protocols implement flash loans, notably Uniswap V2.
Uniswap V2 has been forked into over 600 protocols — more than any other DeFi protocol. It is not possible to understand Uniswap V3 without understanding Uniswap V2 — and Uniswap V3 has been forked into over a hundred protocols. By deeply understanding Uniswap V2, you are positioned to quickly learn hundreds of other protocols. The knowledge gained will serve you many times over. Someone who deeply understands Uniswap V2 can immediately understand hundreds of other codebases.
As you can see, we want to get you to a point of NOT being intimidated by large DeFi codebases but rather understand the recurring patterns they rely on so you can read DeFi codebases in “chunks” rather than try to reverse-engineer them line-by-line.
It is not possible to understand a moderately complex DeFi protocol without having a strong mastery of the subjects above — it’s like trying to learn calculus while having major knowledge gaps with algebra.
Consider that the Uniswap V2 codebase depends on the following topics (and more!):
If you try to learn Uniswap V2 without mastering those topics first, the design choices of Unsiwap V2 will seem random. If you deeply understand the topics above — and you will if you do the assignments leading up to the Uniswap V2 section of the course — then the Uniswap V2 codebase will feel easy and obvious.
Let’s consider some topics we did not include and our rationale for not including them:
Although oracles are critical to DeFi, there is not much to learn about them, and the documentation provided by oracle providers is already very good. Everything you need to know contained, or linked to, in our oracle tutorial. Learning how an oracle works does not “unlock” further skills. It’s one and done.
Proxies can be learned passively if one has the correct foundations and the explanation is clear. Interested students can read our Book of Proxy Patterns which is far more extensive than any other resource on the topic. We’ve seen from experience that developers and auditors have no trouble understanding upgradeable contracts even if they haven’t coded a proxy before, provided they studied the underlying mechanics.
Governance is similar to proxies; it can be learned passively if one has the correct foundations and a good explanation. Furthermore, excellent tooling for implementing governance protocols exists, so reinventing the wheel is usually not the right choice. See our Solidity governance tutorial if interested. Governance matters in the sense that protocols use it, but protocols do not depend on it. Governance is essentially a more decentralized version of a multisignature wallet, so when trying to understand DeFi protocols, developers and auditors can frequently treat governance and DAOs as an abstraction.
Thorough unit testing is rather straightforward nowadays with A.I. While obviously developers should not blindly trust the output of a chat bot, A.I. is very good at “boilerplate” code which unit tests tend to be. If you are unfamiliar with unit testing in Solidity, our article on Foundry Unit Tests is an industry classic. Furthermore, our exercises come with professionally crafted unit tests, so you’ll learn by exposure the best way to write them, as opposed to writing tests with delayed feedback on whether you did it correctly or not.
Invariant testing is important! However, we’ve found it counterproductive to teach invariant testing before the student has strong mastery of at least one DeFi protocol. Otherwise, they don’t know how to come up with invariants, and invariants become more of an academic exercise for the student. By mastering the topics in this course, you will be better equipped to use invariant testing to its full potential. Again, we have an invariant testing tutorial for those interested.
The NFT market is quite dead! Besides, anyone launching an NFT doesn’t need a developer to do it, as there is robust tooling to accomplish this. A developer who wishes to integrate with an NFT can learn everything they need to know in our ERC-721 tutorial and ERC-721 Enumerable tutorial. Additionally, anyone who has mastered ERC-20s to degree this bootcamp trains, ERC-721 will be a walk in the park. With few exceptions, NFTs tend to exist in isolation. So “mastering” NFTs does not set the student up for mastering further topics, as very few topics depend on understanding NFTs.
However, picking the right topics to study is only the first step — the second step is making sure you actually learn these topics.
We learned through experience that “project-based learning” is an inefficient use of time. We replaced it with “exercise-driven training.”
Many educators mistakenly confuse "learning by doing" with "project based learning." It’s better to work on exercises that are designed to give rapid feedback rather than leave students to explore on their own and get delayed feedback as to whether they understood a concept correctly or not.
To get a project to function, there is a strong temptation is to copy working code from stackoverflow or an LLM without understanding how it works. This is fine for a job or hackathon where you are evaluated on shipping features rather than knowing what you are doing. But it is counterproductive for efficient learning as your time is spent expertly crafting your Google search or LLM prompt instead of internalizing a design pattern.
People learn faster when they get direct feedback on their mistakes. A "functional" project doesn't give as much feedback as targeted exercises do. We design our course to maximize feedback. Our exercises are designed to “bite-back” quickly even if a small mistake is made.
Instead, we ask engineers to write code we have already prepared aggressive unit tests for. When the engineer forgets to include a safety feature or deviates from best-practices, the unit tests will give rapid feedback for the engineer to course correct. On top of that, we have 1-1 code reviews with the instructor, but a pre-existing unit test will always provide faster feedback than an instructor can. In our course, you get the best of both worlds.
Even professional code reviewers (aka auditors) miss issues in large codebases; it's very hard to reliably catch every mistake a coder makes. If an engineer learns by creating several projects, but makes more than a few uncaught mistakes, this can lead to engineers creating several projects while also unconsciously enforcing bad habits. That's why we scope our exercises down to where the number of mistakes that could be made are limited and easy to catch.
Check out our GitHub to see some of the exercises we use for training developers and auditors.
The repositories on our GitHub front page alone have well over 1000 stars total.
This serves as indisputable 3rd-party feedback that our learning exercises are incredible.
We encourage you to dig through the rest of our repositories to find hidden gems!
Save 2% if you pay with USDC
Although we believe outcomes are fully your responsibility, we can’t help but brag about some of the incredible people we’ve help along the journey.
Zigtur is the highest earning security researcher of all time in Cantina, with over $600,000 earned in public contests at this time of writing.
Adam Boudjemaa coauthored ERC-3643 and worked as a technical lead (not just a senior engineer) at Polytrade while joining the bootcamp and then joined Biconomy to innovate for account abstraction wallets.
Nicholas Chew was admitted to the prestigious audit firms Spearbit and Guardian Audits shortly after completing the course.
Darian Chan, after completing the course, landed a job at Coinbase as a security engineer, a company that is notoriously hard to get accepted to.
Emil aka Honeymewn went on to be an independent auditor and find over 20 medium and high findings across over seven protocols.
Agent3bood went on to take his first contest winnings of over $8,000 after taking this bootcamp.
This program is for busy engineers who want to upskill in Solidity, but have a job that keeps them busy. Learners who feel stuck in a “doom loop” of studying Solidity but still not being able to make sense of large codebases will also benefit from this.
Here is how you know if this program is a good fit or not:
If you have a lot of time on your hands, we recommend working through the puzzles on our Github and going through our Solidity developer Roadmap.
Please note, there is no “secret tutorials” that we save for our premium members. What you are paying for is instructor time and lifetime access to one of the most respected communities in Web3.
There is absolutely nothing stoping you from working through the exercises on your own and reading the relevant blog articles on RareSkills!
The majority of people who use RareSkills to upskill only use our free material, so it’s perfectly fine if that’s you.
Our claim is you can develop a deep level of understanding of all the subjects listed above in 77 hours using this bootcamp (7 hours per week over 11 weeks). We’ve seen engineers put over 150 hours into study on their own and not achieve the outcomes of this course. So if this course saves you 73 hours (150 - 77) on your learning journey, then you can decide based on your hourly rate, whether this is positive ROI for you.
You should also consider the *likelihood* of completing all the materials as quickly independently as opposed to a community. “Accountability” can be a scary word, but you can also think of this course as “outsourced motivation to stick to an important habit.” In our view, that is a high ROI way to spend money.
Absolutely. RareSkills is the #1 resource for auditors in Web3. Auditors from very established audit firms (such as OpenZeppelin, Consensys, Spearbit, Sherlock, Certora, Immunefi etc) read our materials regularly and frequently cite our articles in audit reports.
Although this isn’t a “security” course per-se, you will still get a lot of practice spotting realistic bugs in production code.
That said, we cannot provide any guarantees about how successful your security career will be — although we should point out that some of our alumni have been *wildly* successful.
For Tokens to DeFi, you should have coded an ERC-20 before, or an NFT.
If we think you are a potential fit, we will reach out to you for an interview.
No. Job guarantees are a marketing gimmick. Your career is completely your responsibility and it cannot be delegated for a price.
We run a Web3 engineering recruitment agency and have directly helped dozens of engineers get new jobs, both from this bootcamp and from non-students who join our recruitment agency through other channels.
We have direct relationships with some of the most influential companies in the Web3 space (meaning we talk with their founders regularly, not that we decided to slap their logo on our website). So we *know* what we are talking about here.
Employers overwhelmingly care about past production experience with Web3. Your “certificates” and “courses” hold zero weight.
This obviously creates a significant chick-and-egg problem for engineers who didn’t join Web3 more than two years ago!
You break the chicken-and-egg problem of experience by repeatedly proving your smart contract skills in a competitive environment such as a hackathon, smart contract security audit contest, or by delivering on grants or bounties for blockchain foundations. You don’t break the chicken-and-egg problem by getting a certificate. There is no industry-recognized certificate that accomplishes it.
Fundamentally, you need to prove you are better than other engineers who want the same job, which can only be done in a competitive setting.
By proving yourself in a competitive setting, you show that you have more of a measurable skill than other candidates and that you have higher intrinsic motivation.
If you are just looking for a new blockchain job, please note that you do not need to be a RareSkills student to use our recruitment agency. You do not need to pay anything or be part of the RareSkills community to use our recruitment services. Fill out the form in RareTalent. If we accept your application, you will get a free 30 minute consultation to work on your resume.
A business quarter has 13 weeks. Since our customers are working professionals for the most part, we find they can accurately forecast their availability up to one quarter in advance, then things become unpredictable.
Therefore, we make our course 11 weeks long to buffer for holidays or major conferences. During major web3 developer conferences (such as Devcon), we may institute a week long vacation for the course and pick up where we left off the week after.
We take vacations during Lunar New Year, New Year, and Christmas week. If a class falls on Eid al-Fitr, Diwali, Thanksgiving, or Good Friday, the class may be postponed depending on the preferences of the class. All postponed classes will be made up for.
Please connect with us here.
Leverage our extensive network of top security specialists.
Join us to build the privacy layer bringing real-world assets on-chain tackling the toughest problems in zero-knowledge and traditional finance.
Founding smart contract engineer role to build core protocols connecting on-chain yield with real-world assets.
Build next-gen blockchain protocols in Rust at Category Labs. Tackle consensus, distributed systems, and performance. Backed by $225M.
