Help us build Version 7.0 of the freeCodeCamp curriculum

Hey freeCodeCamp contributors - soon the freeCodeCamp curriculum will be 100% project-driven learning. Instead of a series of coding challenges, you’ll learn through building projects - step by step.

Before I get into the details, let me emphasize: we are not changing the certifications. All 6 certifications will still have the same 5 required projects. We are only changing the optional coding challenges.

A brief history of the curriculum

OK - Version 7.0! Here’s a history of our curriculum versions to give you some more context:

  • V1 - 2014: I launched freeCodeCamp with a simple list of 15 resources, including Harvard’s CS50 and Stanford’s Database Class.
  • V2 - 2015: We added interactive algorithm challenges.
  • V3 - 2015: We added our own HTML+CSS challenges (before we’d been relying on General Assembly’s Dash course for these).
  • V4 - 2016: We expanded the curriculum to 3 certifications, including Front End, Back End, and Data Visualization. They each had 10 required projects, but only the Front End section had its own challenges. For the other certs, we were still using external resources like Node School.
  • V5 - 2017: We added the back end and data visualization challenges.
  • V6 - 2018: We launched 6 new certifications to replace our old ones. This was the biggest curriculum improvement to date.

Why we need a Version 7.0

Throughout freeCodeCamp’s history, I’ve heard the same two requests almost every day:

  1. Please smooth out the difficulty of freeCodeCamp’s curriculum. It holds your hand for the challenges, then abruptly stops holding your hand during the projects.

  2. Please add more repetition to the curriculum so people can better-retain what they’re learning.

Well, after years - years - of pondering these two problems and how to solve them, I slipped, hit my head on the sink, and when I came to I had a revelation! A vision! A picture in my head! A picture of this! This is what makes time travel possible: the flux capacitor!

:face_with_hand_over_mouth: It wasn’t as dramatic as Doc’s revelation in Back to the Future. It just occurred to me while I was going for a run. The revelation: the entire curriculum should be a series of projects.

Instead of individual coding challenges, we’ll just have projects, each with their own seamless series of tests. Each test gives you just enough information to figure out how to get it to pass. (And you can view hints if that isn’t enough.)

No more walls of explanatory text. No more walls of tests. Just one test at a time, as you build up a working project.

Over the course of passing thousands of tests, you build up projects and your own understanding of coding fundamentals.

There is no transition between lessons and projects, because the lessons themselves are baked into projects.

And there’s plenty of repetition to help you retain everything because - hey - building projects in real life has plenty of repetition.

New and improved tests

The main design challenge is taking what is currently paragraphs of explanation and instructions and packing them into a single test description text.

Old test description text: Your h1 element should have the text “Hello World”.

New test description text: HTML elements have opening tags like <h1> and closing tags like </h1>. Find the h1 element and change the text between its opening and closing tags to say “Hello World”.

Each project will involve dozens of tests like this. People will be coding the entire time, rather than switching back and forth from “reading mode” to “coding mode”.

Instead of a series of coding challenges, people will be in their code editor passing one test after another, quickly building up a project. People will get into a real flow state, similar to what they experience when they build the required projects at the end of each certification. They’ll get that sense of forward progress right from the beginning. And freeCodeCamp will be a much smoother experience.

A screenshot of the Testable Projects people build to earn certifications.

An Overview of the Version 7.0 Curriculum

Each topic will be taught through building a project. Each section within each certification will have a name that follows this pattern: “Learn _______ by building a _______.”

For example, the original HTML curriculum becomes: “Learn HTML by building a cat photo app.”

To this end, I’ve modified our curriculum to make each section project-oriented.

I hope these rough ideas help you visualize what our curriculum could be like.

Learn Responsive Web Design

  • Learn Basic HTML by Building a Cat Photo App
  • Learn Basic CSS by Building a Blog
  • Learn Intermediate CSS by Building a Picasso Painting
  • Learn the CSS Box Model by Building a Rothko Painting
  • Learn CSS Variables by Building a City Skyline
  • Learn CSS Animations by Building a Ferris Wheel
  • Learn Typography by Building a Nutrition Label
  • Learn Accessibility by Building a User Feedback Survey
  • Learn Responsive Web Design by Building a Piano
  • Learn CSS Flexbox by Building a Photo Gallery
  • Learn CSS Grid by Building a Magazine
  • Required Project: Build a Tribute Page
  • Required Project: Build a Survey Form
  • Required Project: Build a Product Landing Page
  • Required Project: Build a Technical Documentation Page
  • Required Project: Build a Personal Portfolio Webpage

Learn Algorithms and Data Structures

  • Learn Basic JavaScript by Building a Role Playing Game
  • Learn Intermediate JavaScript by Building a Calorie Counter
  • Learn Regular Expressions by Building a Spam Filter
  • Learn Debugging by Building a Dice Game
  • Learn Data Structures by Building a Shopping Cart
  • Learn Algorithms by Building an Algorithmic News Feed
  • Learn Functional Programming by Building a Spreadsheet
  • Required Project: Palindrome Checker
  • Required Project: Roman Numeral Converter
  • Required Project: Caesars Cipher
  • Required Project: Telephone Number Validator
  • Required Project: Cash Register

Learn Front End Libraries

  • Learn React by Building Flappy Bird
  • Learn Redux by Building Tetris
  • Learn TypeScript by Building a Poker Game
  • Required Project: Build a Random Quote Machine
  • Required Project: Build a Markdown Previewer
  • Required Project: Build a Drum Machine
  • Required Project: Build a JavaScript Calculator
  • Required Project: Build a Pomodoro Clock

Learn Data Visualization

  • Learn CSV by Building a Mailing List
  • Learn JSON by Building a Sports Team
  • Learn AJAX by Building a View Counter
  • Lean Data Visualization by Building a Dashboard
  • Learn SVG by Building a Solar System
  • Learn D3 by Building a Map of Earth
  • Required Project: Visualize Data with a Bar Chart
  • Required Project: Visualize Data with a Scatterplot Graph
  • Required Project: Visualize Data with a Heat Map
  • Required Project: Visualize Data with a Choropleth Map
  • Required Project: Visualize Data with a Treemap Diagram

Learn APIs and Microservices

  • Learn npm by Building an npm Module
  • Learn Node.js by Building a Web Server
  • Learn Express.js by Building an Stock Trading Platform
  • Learn RESTful APIs by Building a Weather Service
  • Learn MongoDB by Building a Movie Review Database
  • Required Project: Metric-Imperial Converter
  • Required Project: Issue Tracker
  • Required Project: Personal Library
  • Required Project: Stock Price Checker
  • Required Project: Anonymous Message Board

Learn Information Security and Quality Assurance

  • Learn Information Security by Building a Credit Card Form
  • Learn Cryptography By Building a Digital Signature System
  • Learn Testing by Building a Recipe Ingredient Parser
  • Learn Authentication by Building a Signup Page
  • Learn Websockets by Building a Chat Room
  • Required Project: Metric-Imperial Converter
  • Required Project: Issue Tracker
  • Required Project: Personal Library
  • Required Project: Stock Price Checker
  • Required Project: Anonymous Message Board

How You Can Help Us Build This

We’ve already started designing these projects. For example, here’s what we the “Learn Basic JavaScript by Building a Role Playing Game” project looks like:

Here’s @beaucarnes’s CodePen implementation if you’re curious:

People will learn JavaScript by building up this game one test at a time.

Here’s what the tests for the “Learn HTML by Building a Cat Photo App” currently look like:

It will take several months to build all these projects, their associated tests, and to QA everything. Our plan is to roll these new projects out to the curriculum as we finish them.

And that’s where you, kind person who has read this far, come in.

The last time we updated the curriculum, we had dozens of amazing contributors who helped with the process. And we are optimistic that together, we can build these projects even more quickly.

We need help with the following:

  • Building the initial projects
  • Taking these projects and working backward, disassembling them into a series of dozens (hundreds?) of concise test descriptions
  • Once we have the test descriptions, we need to implement the tests themselves

I’ve created a GitHub Project we can all use to track the overall progress of Version 7.0 of the curriculum here:

If you’re serious about contributing, here’s what I recommend you do:

  1. Leave a comment below, introducing yourself and sharing your thoughts on all this
  2. Join the freeCodeCamp Contributor Chatroom if you haven’t already:
  3. Comment on the GitHub issues of the projects you are interested in helping with. Even the most general of ideas or prototypes will help us kick off this process. The issues for these are all located on our Curriculum Expansion repository:

With your help, the millions of people who are learning to code through freeCodeCamp will have an even better resource to help them learn these fundamentals, and gain the confidence to build more ambitious projects.

Update April 7: @scissorsneedfoodtoo just published an official FAQ for people contributing to the updated curriculum. If your question isn’t on there, ask and we can answer it :+1:

Update April 12: @scissorsneedfoodtoo is now focused on QA’ing the curriculum expansion full-time. He is mentoring contributors and helping them get their projects and tests merged into the repo, and making great progress, which you can follow here:

Update May 15: A couple of project titles have been updated. “Learn Testing by Building a Fact Checker” is now “Learn Testing by Building a Recipe Ingredient Parser”, and “Learn Accessibility by Building a Website for People with Disabilities” was changed to “Learn Accessibility by Building a User Feedback Survey”.

Update May 22: Added the “Learn Basic CSS by Building a Blog” project and changed “Learn CSS by Building a Picasso Painting” to “Learn Intermediate CSS by Building a Picasso Painting”.

Update May 23: Changed “Learn Debugging by Building an Earthquake Warning System” to “Learn Debugging by Building a Dice Game”

Update June 26: Changed “Learn Algorithms by Building a Search Engine” to “Learn Algorithms by Building an Algorithmic News Feed” and “Learn Cryptography by Building a Password Hasher” to “Learn Cryptography By Building a Digital Signature System”


Hello. I’ve recently delved into FCC and think this is a simple yet great idea. This should help maintain a context with the student that what they are learning has a purpose and when they have completed said project they can see what that purpose is.

I’ll help where I can!


This is wonderful!

I like the idea of learning by doing in this particular case of fCC learning by building, building and building. It is much more fun building projects!

I have just earned my Responsive Web Design Projects certification today, and I can tell that while the transition between lessons and projects is not that hard. I find it tricky at the times because the transition as it has been said is not smooth and in the end when I start building the projects I found myself grinding for clues.

I will try to help and contribute where I can as I am kind of new and never contribute to any code related projects before.


First of all a HUGE shout-out for keeping FCC moving forward!
Sounds trivial, but I know how much work, thoughts and fatigue goes into each step.

So props to @QuincyLarson, and all the FCC contributor for the constant effort.

Now, if I may, I would like to raise two main “concerns” I had:

  • I fear at some point some longer explanation of some sort would be required.

I am not talking about long college-like lectures, but at least some sort of explanation about the reasoning why certain things are the way they are is mandatory.

I have a feat that without it, a new camper with zero experience in coding, following only directives, will end up knowing how to do a thing because “that’s what I was told to do” instead of “I do it like this because…”

So in my opinion finding a good compromise between “a boring wall of explanatory text” and “dynamic yet informative” will certainly be a challenge :slight_smile:

  • Hitting a wall, and overcoming it, is one of the most valuable lessons to learn.

We have all been there. Not only during the learning process, but also on the job.
There will always be a time where, as a dev, you will have to face a challenge that you have no clue how to overcome (yet!).

Learning to roll up my sleeves, do my own research, being frustrated, waste days (that always in retrospection are never a waste but experience gained regardless) of time only to do what seems basic, but ultimately overcome them, is what made me the developer I am.

Again, I think that finding a good compromise between “smashing into a wall”, and learning to struggle will be another good challenge. :slight_smile:

That said I’ll see If I can contribute more concretely… looking at you flappy-bird-react :eyes:


Wow so much excited when you are planning to launch .
Thank You Free Code Camp Team
Thank you


These are both great points.

Let me reply one-by-one.

  • I fear at some point some longer explanation of some sort would be required.

The challenge is to break concepts down into small enough bits that a sentence or two will suffice. Show instead of tell - and do this through painstakingly designed tests.

Think about all of the complexity in a modern video game like Starcraft or Civilization. And yet, all the teaching is done just-in-time. People don’t generally read manuals, and video games have stopped even including manuals. Instead they have single sentence explanations peppered throughout the experience.

“Don’t shoot the food.” Why not? Oh, I shot the food and it disappeared, so I couldn’t eat it. With coding, these kinds of “teachable moments” are everywhere, and the consequences of mistakes are negligable - just hit the “reset my code” button and you’re right back “on the rails” where the tests want you to be.

Why should you generally use === instead of == in JavaScript? Show - don’t tell. It will take some creativity, but I’m confident we can impart the “why” along with the “how” through these tests.

Learning to roll up my sleeves, do my own research, being frustrated, waste days (that always in retrospection are never a waste but experience gained regardless) of time only to do what seems basic, but ultimately overcome them, is what made me the developer I am.

Same here! But I almost quit many times. And I was focused on learning full time.

Imagine if I had just come home from a full day of work, put my kids to bed, and finally sat down at the kitchen table. That’s most people who use freeCodeCamp. And these people tend to give up and then restart several times before they are able to successfully get a developer job. By keeping people on a “golden path” - at least initially - we are are able to keep more people progressing with their skills.

There will still be plenty of head-scratching once they get to the Required Projects. We can gradually ramp up the difficulty leading up to those, so it’s not such a steep learning curve.

That said I’ll see If I can contribute more concretely… looking at you flappy-bird-react :eyes:

We would welcome your help with this. See whether you can build a bare-bones implementation for starters. Then we can work backward to break it down into a series of tests.


What are the plans to make JS-based projects testable at each step without locking everyone into exactly the same codebase? For example, when introducing, say, higher order or arrow functions, are there going to be specific functions that are required by name, taking and returning specific data structures, or are the tests going to be more functional based on the expected outputs, trusting the user to use the proper implementation?

As it is now, the challenge course does have a certain rigidity to each challenge, but the reins are loosened slightly in the honor-system projects. I’ve seen more than one example of a project that passes in functionality, but can’t pass the test suite regardless without major rewrites.


I love the idea of Learn React by building Flappy bird, I’ve just finished the React course and i’ll be doing it again with v7.0. In general though this sounds a great idea of project based learning, especially giving context to what you can do with a tech.

I’d like to help too!


Cheers @QuincyLarson

I figure some kind of curriculum update has been due for awhile. Certainly, I can see how building toward a working project vs just plugging away at exercises that might or might not seem obviously connected, could keep learners motivated. I’m definitely intrigued and would like to contribute.

The one thing that really stood out for me in the original post, however, was this:

Throughout freeCodeCamp’s history, I’ve heard the same two requests almost every day:

  1. Please smooth out the difficulty of freeCodeCamp’s curriculum. It holds your hand for the challenges, then abruptly stops holding your hand during the projects.

Personally, this is what I really appreciated about the curriculum; having to really struggle with the projects made getting the full-stack certification that much more rewarding.

Either way, I’m hopeful that better things are coming, and I look forward to contributing in whatever way I can.


I’d recommend you to read this before starting:

Maybe it’ll help you avoid the train-wreck that the current projects/tests are.


I agree with valuing the The Struggle aspect of the curriculum as-is. Maybe it’s because I tend to be somewhat of an autodidact but I think the challenge-level seems just right enough to reward those who choose to stick with it while “weeding out” those who want more than what is already provided.

I mean, as it is, FreeCodeCamp is FREE and has a supportive forum that offers me quick support when I’m stuck. What more can one ask for? Further, it seems to me that the wall-of-words aspect of FCC might aid in training would-be developers to read tech documentation.

All that said, FCC seeming near perfect in difficulty to me might just be to do with my personality. I am so thankful that FCC is around and will contribute in the future versions in anyway that I think I can.


That’s correct - these new projects will be rigid to keep people from straying off too far into the weeds. So yes, everyone’s projects will look the same, and have the same resulting codebase. Rather than serve as portfolio projects you’d showcase, building these projects is purely for learning purposes.

The required projects at the end of each certification, on the other hand, are open ended. The tests are designed to be as flexible as possible to afford plenty of personalization.

And even though you could in theory submit a plagiarized project and claim a certification, we do audit these submissions and catch cheaters all the time (we have a special isCheater flag - kind of a scarlet letter. Don’t cheat, folks!)


We aren’t going to completely remove the struggling - we’re just going to better prepare people for the struggling. Life is a struggle - learning to code is no different.

We just want to keep people on a “golden path” initially so they have time to acclimate.

freeCodeCamp will still be extremely challenging.


I heartily disagree with the comments supporting the sudden challenge ramp-up. People will hit a wall regardless, because everyone has different learning processes, but if everyone is hitting the same wall, then there’s clearly something wrong with the challenge course.

@QuincyLarson: Cool, I wasn’t sure if the challenge projects were going to be the cert projects too. In that case, I guess it does make sense to have rigid “challenge course projects” and open-ended completion projects.


It is impossible to determine which route of instruction would be the best–unless there are future seers among us.

But I don’t think that it can be said that “there’s clearly something wrong” with FCC. A challenge point or commonly hit wall doesn’t immediately point to a flaw in the program.

In fact, some might argue that walls are good to hit and overcome. For example, I’ve been hitting walls for the last 7 months but overcame them left and right and still continue to hit and overcome them. I feel that this is instilling a good work ethic and confidence to tackle difficult challenges as well as training me to look things on my own (an ability that is said to be necessary in programming).

Only the future will tell if Quincy’s new approach with FCC will be more effective than the current one, but to suggest that the current method is “wrong” ignores the fact that plenty of people (including me) have responded well to the curriculum.


I’m not saying there’s anything wrong or broken with FCC overall – flaws can still exist in an otherwise terrific learning platform, and part of that excellence is about acknowledging and fixing defects as they’re discovered. Like I said before, if nearly everyone is hitting a wall at the same point in the curriculum, then that needs to be addressed as a potential bug, whether it’s the wording of the challenge or gaps in the curriculum.

I’m also excited about the project approach, which should make those challenges a lot more interesting as people get invested in the project as it develops. I’m amazed at how much FCC has evolved in the time I was away only a couple of years ago, and I look forward to seeing what amazing stuff they come up with next.


I disagree about the wall being a bug–to me it’s a feature.

But I’m with you on seeing FCC evolve!


Couldn’t resist…


Looking forward to what’s coming next. Very exciting


I’d love to help! Joined the FCC Contributors Gitter.