# Inside the freeCodeCamp monorepo: build targets, certification gates and a split licence

> This is the TypeScript workspace behind freeCodeCamp.org and the curriculum it serves, packaged as a private pnpm workspace with three separate build targets and no releases. It answers none of your install questions, and the licence changes halfway through the repository.

**freeCodeCamp/freeCodeCamp** — GitHub describes it as freeCodeCamp.org's open-source codebase and curriculum. Learn math, programming, and computer science for free.. The repository metadata lists TypeScript as its primary language. The metadata lists the BSD-3-Clause license. This article stays within the project description and details documented in the GitHub repository README.

- Repository: https://github.com/freeCodeCamp/freeCodeCamp
- Website: https://contribute.freecodecamp.org
- Stars: 456,340 · Forks: 47,563
- Language: TypeScript
- License: BSD-3-Clause
- Published: 2026-08-13 · Updated: 2026-08-24 · Language: en
- Canonical page: https://hysenlabs.com/projects/freecodecamp-freecodecamp

## Node 24 and pnpm 10 decide whether anything builds at all

The root package.json names the workspace @freecodecamp/freecodecamp, pins version 0.0.1, sets "private": true, and gives the entry point as "none". That last value is the clearest signal in the file. There is no importable module here, nothing published to a registry for a downstream project to consume. What you get is a workspace declared in pnpm-workspace.yaml, with turbo.json at the root orchestrating it and the work split across api/, client/, curriculum/, packages/ and tools/.

Before any of that compiles, the engines field settles the argument about versions.

```json
"engines": {
  "node": ">=24",
  "pnpm": ">=10"
}
```

npm is not the package manager even though several scripts invoke it. pnpm-lock.yaml is the lockfile, and the .nvmrc file at the root is the other half of that pin. Getting this wrong is not a small annoyance, because .gitmodules tells you submodules have to be fetched separately, and one of the setup scripts is literally a git submodule command. A clone plus an install in the wrong package manager gives you a tree that never matched what the repository was worked on.

## Three build targets, and a clean that deletes every node_modules

Builds are scoped per workspace package rather than run as one sequence, because turbo.json sits at the root and the scripts only pick filters.

```json
"build": "turbo build",
"build:client": "turbo -F=@freecodecamp/client build",
"build:curriculum": "turbo -F=@freecodecamp/curriculum build",
"build:api": "turbo -F=@freecodecamp/api build"
```

Only one piece of generated state is named by path anywhere in the scripts, and it belongs to the curriculum:

```bash
"clean:curriculum": "rm -rf ./curriculum/generated/curriculum.json"
```

The other two clean tasks are blunt. clean:packages walks the tree and removes every node_modules directory it finds, and clean:turbo does the same for every .turbo cache directory. The aggregate clean runs the three targeted tasks with --serial and then the packages wipe, so a full reset takes you back to a fresh clone plus install. There is a one-shot script for exactly that sequence:

```json
"clean-and-develop": "pnpm run clean && pnpm install && pnpm run develop"
```

Two directories at the top level, docker/ and e2e/, sit outside the turbo graph, and .devcontainer/ suggests a container path exists for the environment.

## The README routes you to a wiki and never states an install step

The Contributing section contains no commands at all. It links to contribute.freecodecamp.org and stops. The bug path works the same way: instead of describing how to reproduce a failure locally, it points at a forum thread on how to report a bug and asks you to confirm that someone else is already hitting the same issue before opening a GitHub issue. The setup procedure is not in this repository.

Two consequences follow for anyone who clones it. You can end up with a clean working tree and no running site, and the reason is a missing wiki page rather than a file you forgot to run. And the two scripts that come closest to a first run are both about authoring, not about serving.

```json
"challenge-editor-setup": "git submodule update --init tools/challenge-editor && cd tools/challenge-editor && pnpm install",
"challenge-editor": "cd tools/challenge-editor && pnpm dev"
```

The first has to run before the second, because the editor lives in a submodule that git does not populate on a plain clone. For learners the gap is the mirror image. The README points only to the live site and lists a forum, a YouTube channel, a publication and a Discord server around it. It does not document any offline mode for the exercises, and no script in the root package.json exports or synchronises your progress.

## Five required projects stand between a developer certification and its exam

Six developer certifications make up the Full-Stack Developer Curriculum: Responsive Web Design, JavaScript, Front-End Development Libraries, Python, Relational Databases, and Back-End Development and APIs. Each is assembled from the same five primitives, interactive lessons, workshops, labs, reviews and quizzes, and each closes the same way. You need 5 required projects to qualify for the exam, and you need to pass the exam before you can claim the certification.

The projects are the expensive part, and they are where working through material turns into something a reader can look at. What this structure cannot do is compress. The requirement is five per certification, not five across the whole curriculum, so the learner who collects every credential in order finishes far more than six projects. Labs, reviews and quizzes completed along the way earn nothing toward that count.

The repository carries tooling for the content behind those gates, and the scripts show where authors work:

```json
"audit-challenges": "cd curriculum && pnpm audit-challenges",
"create-new-project": "cd ./tools/challenge-helper-scripts/ && pnpm run create-project"
```

Both live under curriculum/ and tools/, which is the split the licence question turns on.

## Language certifications invert the gate: every quiz, in order

The four language certifications are built differently from the six developer ones. Each is organized into modules, and a module is cut into warm-ups, lessons, practice exercises, review pages and quizzes. The entry requirement is different too. A developer track asks for five required projects; a language track asks you to complete all of the quizzes in order before you qualify for the exam.

The phrase in order carries the whole design. The sequence is the requirement, so a learner cannot park a module and return to it later, and cannot drop the review pages on the assumption that the material was already covered in the lesson. The cost of that structure is that nothing is skimmable and nothing is resumable.

All four carry a Beta label: A2 English for Developers, B1 English for Developers, A1 Professional Spanish and A1 Professional Chinese. The README does not say what Beta constrains. Whether it limits content, stability, exam availability or something else is not settled anywhere in this repository, so a learner who plans a multi-month schedule around one of these tracks has to check the live site before committing the hours.

## The only way to lose a permanent certification is the Academic Honesty Policy

Once earned, a certification is described as permanent. You keep it, you can link to it from a LinkedIn profile or a resume, and the page a prospective employer or freelance client opens shows a verified certification tied to you specifically. The README states that with no time limit and no renewal, which is an unusual position for a free program with no enrollment fee.

One exception exists, and it is enforced rather than advisory. The repository names an Academic Honesty Policy and describes the response to unambiguous plagiarism, submitting other people's code or projects as your own without citation: the certifications get revoked and the people get banned. Permanence is therefore conditional on provenance, and the penalty lands on the credential and the account together.

What the README does not document is a process. There is no appeal route, no review step, no grace period and no stated standard for how a reviewer decides what counts as unambiguous. A learner leaning on the promise of a credential that never expires is relying on being able to say, at any later date, exactly which lines came from which keyboard.

## There is no release to pin and no version number to compare

The repository has no GitHub releases. There is no tagged artifact to install, no changelog to diff, and no published version in the root package.json either, which sits at 0.0.1 behind "private": true. Anyone tracking this codebase tracks the main branch, and the last push landed on 2026-09-26.

The supporting files describe a working routine even with no releases attached. renovate.json sits at the root, which is where dependency update automation is configured. .github/ holds the rest of the automation, .husky/ is present for git hooks, and knip.jsonc is set up so unused files and exports are meant to be flagged instead of accumulating. None of that gives you a stable version to pin against. It tells you the branch is being worked on, and that whatever you get is whatever the tip of main is when you clone it.

For a curriculum that people are meant to trust as a learning artifact, that is a real difference from a pinned dependency. There is no known-good version to fall back to if a change to the client or the build graph breaks your local run.

## Interview prep is bundled from other projects, with no stated boundary

The certification list is not the whole offer. Alongside the curriculum the README points to The Odin Project, described as a freeCodeCamp Remix, plus Coding Interview Prep, Project Euler and Rosetta Code, and it also advertises a free professional Foundational C# certification with Microsoft. The outcome claim attached to all of it is that the community has already helped more than 100,000 people get their first developer job. That figure is the charity's own, and it is the only outcome number in the repository.

What none of this tells you is how the parts divide. The Odin Project is a separate path with its own structure, and nothing says which freeCodeCamp certifications share exercises with it, whether Project Euler or Rosetta Code problems count toward any required project, or whether the Microsoft credential carries the same weight as a freeCodeCamp certificate. A learner deciding where to spend the next hundred hours is working from a list of links rather than a map, and the repository offers no way to check the overlap.

The funding model is at least explicit. The project describes itself as a donor-supported 501(c)(3) charity, which tells you who pays for the servers and who decides the curriculum, and it is the one governance fact stated anywhere in the README.

## Conclusion

Adopt this repository if you intend to write challenges for the platform or run the site locally, and if you can live inside Node 24, pnpm 10 and a branch that has never been tagged. Do not adopt it expecting a packaged library, a pinned release, or a README that walks you to a running site; those steps live on contribute.freecodecamp.org, and the learning content sits under a different copyright from the BSD-3-Clause code. Before writing a single challenge, open LICENSE.md and read the line about the /curriculum directory, because that boundary is the first thing that will stop a contribution.

## FAQ

### What is freeCodeCamp and what does it do?

It is a donor-supported 501(c)(3) charity that publishes a free, self-paced full-stack web development and machine learning curriculum, and this repository holds both the TypeScript codebase that runs freeCodeCamp.org and the curriculum content. Each developer certification mixes interactive lessons, workshops, labs, reviews and quizzes, and the README says thousands of coding challenges are available.

### How do I get a freeCodeCamp certificate?

You complete 5 required projects to qualify for the exam, then pass the exam to claim the certification. Once earned it is described as permanent, and you can link to it from a LinkedIn profile or a resume where employers and freelance clients see a verified certification.

### How do I take the freeCodeCamp exam?

For a developer certification, finishing 5 required projects is what qualifies you to sit the exam. For the language certifications the requirement is different: you must complete all of the quizzes in order before you qualify for the exam at the end.

### Can I use freeCodeCamp offline?

The README does not document an offline mode for learners. It describes the platform as running live at freecodecamp.org and points to that site, its forum, YouTube channel and Discord server, and the root package.json contains no export or sync command.

### Is a freeCodeCamp certification worth anything?

The README claims the community has already helped more than 100,000 people get their first developer job, and that a claimed certification is permanent and verifiable through a link on your resume or LinkedIn profile. The one stated exception is the Academic Honesty Policy, under which unambiguously plagiarized work gets the certification revoked and the account banned.

### How do I contribute to freeCodeCamp?

The README contains no install steps of its own and sends contributors to contribute.freecodecamp.org. In the repository you will find the runtime requirements instead: Node 24 or newer and pnpm 10 or newer, a pnpm workspace driven by turbo.json, and a challenge editor that lives in a git submodule and needs fetching before it can run.

## Sources

- [Official documentation](https://contribute.freecodecamp.org)
- [Official README](https://github.com/freeCodeCamp/freeCodeCamp#readme)
- [Project repository](https://github.com/freeCodeCamp/freeCodeCamp)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/freecodecamp-freecodecamp