You may be thinking: school alone is plenty of work! And it often is. But if you set your mind to it, like I did, you'll be amazed at what you can do.

In this story, I’ll share my journey of working through and receiving 15 freeCodeCamp certifications in just four months.

What I'll Cover:

• My Beginning with the Digital World

• Starting My Journey with freeCodeCamp

• Benefits of freeCodeCamp's Methodology

• freeCodeCamp Learning Paths

• 1- Responsive Web Design Certification.

• 2- JavaScript Algorithms and Data Structures

• 3- Scientific Computing with Python

• 4- Data Visualization

• 5- Backend End Development and APIs

• 6- Front End Development Libraries

• 7- Data Analysis with Python

• 8- Machine Learning with Python

• 9- Quality Assurance

• 10- Information Security

• 11- Legacy Certifications

• Personal recommendations

My Beginning with the Digital World

I grew up in a family that really believed in life-long learning.

At an early age – around 10 – my father bought me my first laptop.

From there, learning became part of our daily routine. My father approached it with structure and intention. He designed a complete detailed learning plan for me.

Looking back, it was quite ambitious for someone my age. But my father always believed in high standards and expectations.

Still, we didn’t start with programming right away.

At first, we explored different areas and domains. I focused on trying to find something I though was interesting.

But it didn’t take long before we realized how important programming was becoming and how powerful it could be to start early.

So, we decided that I should start learning programming.

I began with HTML, building my very first web page. I was able to build a complete web page using different elements and tags on my own.

It was simple but it worked. That moment felt like a win.

Then I moved on to CSS. I was able to style and arrange the elements on the web page the way I liked. I grasped many CSS techniques and commands that help control the layout and arragement of elements so I could make them look the way I wanted.

After that came JavaScript. That’s when I was able to make things more alive. I started adding movement, interaction, and behavior to my web pages.

And I didn’t stop there.

I stepped into backend development with PHP, beginning to understand how things worked behind the scenes. Alongside that, I started learning SQL to handle databases – an essential part of building real, functional web applications.

Step by step, the picture was becoming clearer.

Before learning about these languages, the web sound like a black box. But after I finished learning them, I started looking at websites from a different angle, and I started recognizing how web pages are made.

All this learning came through a mix of YouTube lessons and structured courses my father invested in for me, like a 50-hour PHP course on Udemy.

I was absorbing a lot, moving from one concept to another, and building small pieces along the way.

But at some point, something clicked: I realized that watching tutorials – even long, detailed ones – wasn’t enough on its own. There was a gap between understanding concepts and building something real. So I decided I needed to dive deeper.

Starting My Journey with freeCodeCamp

I needed to move beyond lessons into building structured, meaningful web applications. Projects that weren’t just exercises, but had real purpose.

Projects with expectations, constraints, and even real stakeholders.

The kind of work that forces you to think, to make decisions, and to take ownership.

Because there’s a big difference between following along with a video… and sitting alone in front of a blank screen, figuring things out step by step.

That shift helped me avoid what many learners fall into: the endless loop of tutorials without real progress (Tutorial Hell).

And for the first time, I started to feel what it really means to build.

That’s when I made a clear decision to switch to freeCodeCamp. What drew me in was simple: it wasn’t just lessons. It was practice building real, structured, hands-on projects.

Benefits of freeCodeCamp's Methodology

After completing 15 certifications on freeCodeCamp, I was able to build and launch a full platform called Programming Ocean Academy, focused on Data Science and Artificial Intelligence.

It pushed me to think, to solve problems on my own, and to act like an engineer – not just a learner following instructions.

This wasn’t a small project. It included:

• A fully functional frontend and backend system

• More than 25 databases

• Over 150 pages

• Integrated training platforms

But what mattered more than the scale… was what came next.

Because of the strong logical and programming foundation I had built, transitioning into Data Science and AI felt natural and not overwhelming.

I moved into Python and its ecosystem with confidence. From there, I worked with powerful libraries like scikit-learn, TensorFlow, and PyTorch.

The solid foundation I'd built enabled me to deliver multiple training programs in collaboration with Arab universities, and I've helped train more than 5,000 learners.

Looking back, that shift from consuming content to building real systems and delivering courses was the turning point.

freeCodeCamp Learning Paths

Today, I’m happy to share this journey with you and to emphasize something I’ve come to believe deeply: the programs and learning paths offered by freeCodeCamp aren't just courses. They're a structured bridge that'll help take you from being someone who watches tutorials and writes code to someone who builds real applications and creates products that serve people.

Now, you have the context you need to understand the rest of the story.

So let’s begin.

This is where the journey with freeCodeCamp really starts. A journey I would confidently recommend to anyone who wants to enter the world of programming and technology with clarity and direction.

How did it start? And how did I choose my path?

At the beginning, I didn’t approach freeCodeCamp randomly.

I knew that if I wanted real progress, I needed structure.

So instead of jumping between topics, I followed a clear order – one that builds understanding step by step, just like constructing a solid foundation before raising a building.

I asked myself a simple question: What do I need to master first, so everything that comes after becomes easier not harder?

That question influenced everything that followed.

So instead of creating my own path from scratch, I decided to fully trust the methodology of freeCodeCamp, following its order of certifications, lessons, and progression exactly as designed.

That decision made everything simpler.

I started from the very beginning and moved step by step.

My journey began with:

1: Responsive Web Design Certification.

At that time, I was studying for around 8 hours a day on most days, balancing it with my school responsibilities. It wasn’t always easy, but the structure kept me focused.

During this first phase, I built a strong foundation.

I explored HTML in depth:

• Understanding almost all HTML tags

• Knowing the purpose of each element

• Learning which attributes belong to which elements

• When to use each tag properly

• Writing clean, semantic code that follows best practices

Then came CSS. This is where things evolved visually.

I started understanding more deeply how to:

• Style and structure pages

• Create modern, clean layouts

• Build responsive designs that adapt across devices

But the real test wasn’t the lessons.

To earn the certification, I had to complete five full projects, each one requiring me to apply everything I had learned, solve problems independently, and choose the best possible approach rather than just making things “work.”

That’s where the real learning happened.

2: JavaScript Algorithms and Data Structures

For the second certification, JavaScript, things took a different turn.

This is where the web stopped being static.

I learned how to make pages interactive and alive. I learned how to control behavior, respond to user actions, and build logic that does something. But more importantly, I spent time learning how to think logically.

JavaScript pushed me into algorithmic thinking:

• Breaking problems into smaller steps

• Writing logic in a structured, methodical way

• Building solutions that are not just correct but clean and scalable

And after that phase, I didn’t stop at just using freeCodeCamp's curriculum.

I wanted to go deeper.

So I started solving programming challenges on platforms like Codewars and Edabit. Those challenges sharpened my thinking even more. They forced me to face unfamiliar problems and figure things out without guidance.

3: Scientific Computing with Python

Then came the third stage of the journey.

This phase was different. Python had its own elegance, its own logic, and a strong connection to mathematics and data.

It opened a completely new way of thinking.

Through hands-on projects, I learned how to work with data using powerful tools like NumPy, pandas, and Matplotlib. And I didn’t just learn how to use these tools. I got familiar with what they enable.

I practiced:

• Analyzing data

• Exploring patterns

• Visualizing insights

• Thinking statistically

• Moving from raw data to meaningful conclusions

I began to understand how data can be transformed into real insights That’s when my skills started to become more powerful.

My first real encounter with Python and data analysis was through freeCodeCamp.

Unlike web development – which I had explored earlier through different resources – this was my first entry point into the world of data.

And for that, I honestly give freeCodeCamp a lot of credit. It didn’t just introduce me to new tools. It introduced me to a completely new way of thinking.

4: Data Visualization

This phase added a new dimension. It wasn’t just about working with data anymore – it was about communicating it's meaning.

I learned how to transform raw numbers into clear, meaningful visualizations. I explored how to create graphs that don’t just look good but help you understand what’s going on beneath the surface.

That experience was incredibly valuable

It built a foundation that later made my transition from web development into data science and AI much smoother.

And once again, I must acknowledge the role of freeCodeCamp. Because during this phase working with tools like Python, Matplotlib, and pandas, I began to truly understand the importance of data visualization and analysis.

I started to carry this mindset back into the world of web development:

• Into databases

• Into SQL tables

• Into how data is structured, queried, and interpreted

I realized that data isn't just something you store. Its value comes from how well you can understand it, analyze it, and use it.

And for stakeholders, this is just as critical as storage, security, and privacy because without insight, data alone means very little.

This distinction is incredibly important for every developer to understand.

In the world of web development, the focus is often on storing data, securing it, and making sure it’s accessible. But in the world of data analysis, scientific computing, and statistical modeling, the focus shifts completely.

It becomes about studying the data itself transforming it from something silent… into something that speaks. Something that guides decisions. Something that helps you improve systems, refine products, and make smarter long-term choices.

That shift in perspective changed the way I handled everything.

5: Backend End Development and APIs

This was a new world.

Even though I had previous experience with PHP and SQL from Udemy, this path introduced me to a different ecosystem which is modern, fast, and widely used in real-world applications.

Of course, the beginning wasn’t easy. I had no prior experience with tools like Node.js or MongoDB. It felt unfamiliar at first, and there was a learning curve.

But this is where freeCodeCamp stood out again.

They didn’t just throw you alone into the deep end. They supported the journey.

I found dedicated courses on their YouTube channel like a full Node.js course (around 8 hours) and a MongoDB course (around 4 hours).

I went through both of them completely. Step by step, things started to make sense. I built a solid foundation, returned to the certification path, and this time I was ready.

I completed all the challenges and projects successfully, from the first attempt.

And that experience taught me something important: sometimes the path forward isn’t about pushing harder, it’s about stepping back, strengthening your foundations, and then coming back stronger.

One of the most interesting parts of this stage was discovering the difference between how data is handled in SQL versus MongoDB.

It wasn’t just a technical difference, but a shift in mindset.

With SQL, everything is structured, relational, and predefined. With MongoDB, things are more flexible, document-based, and dynamic.

Learning to work with both gave me a broader perspective on how to design and manage data depending on the problem at hand.

6: Front End Development Libraries

This was one of the most enjoyable phases. It felt creative, fast, and powerful.

I explored frameworks and libraries like:

• jQuery

• React

• Vue.js

To strengthen my understanding, I followed additional courses on the freeCodeCamp YouTube channel, making sure I had the right foundations before tackling the projects and passing the certification requirements.

What stood out to me the most during this phase was something new: for the first time, I truly learned how to control HTML and CSS through JavaScript in a structured and scalable way.

This wasn’t just about styling anymore, but it was about building dynamic interfaces, managing state, and creating responsive user experiences.

And honestly, this was the first time I grasped this concept deeply.

7: Data Analysis with Python

Here, things became more precise.

I explored how to:

• Choose the right type of visualization depending on the data

• Analyze datasets using tools like Excel, NumPy, and pandas

• Create advanced visualizations using libraries like D3.js

I was learning how to think with data, how to read it, question it, and turn it into something meaningful.

8: Machine Learning with Python

This new learning path was deeper, more abstract. Sometimes even unfamiliar compared to everything I had learned before.

For the first time, I wasn’t just writing code to build applications. I was building models that learn from data.

Working with tools like TensorFlow, I began to understand how data, mathematics, and algorithms come together to create intelligent systems.

Everything I had learned through freeCodeCamp started to reflect beyond programming itself.

I noticed the impact in school:

• In mathematics, logic became clearer

• In digital technology, concepts felt more intuitive

• Even in subjects like physics and chemistry, problem-solving became easier

Because at its core, my way of thinking had changed. My logical reasoning had become stronger. Working with algorithms and mathematical expressions no longer felt difficult. Instead it felt natural.

One of the most meaningful outcomes of this journey came during high school. A teacher trusted me with a responsibility I didn’t expect: To explain programming lessons to my classmates.

And I did.

Not just by repeating information but by simplifying it, structuring it, and making it understandable. That moment I discovered that learning deeply allows you to teach clearly.

And then came a new and powerful phase: building the engineering mindset.

At this stage, everything started to come together. It was about thinking differently.

An engineering mindset built on:

• Strong logical foundations

• Real project experience

• Understanding how systems behave, not just how code runs

And this introduced me to the upcoming certifications.

9: Quality Assurance

I spent time learning how to write code that's not only functional but reliable, maintainable, and scalable.

Using tools, and practices like Chai.js, I began to:

• Test applications properly

• Catch errors early

• Ensure systems run smoothly under different conditions

And this is where the real transformation started happening. I started moving from being someone who writes code to someone who builds systems.

10: Information Security

Through the cybersecurity path on freeCodeCamp, I was introduced to a completely new dimension of software development: thinking about protecting systems, not only building them blindly.

I picked up essential concepts and practical skills using tools like:

• Helmet.js to secure web applications

• Python for penetration testing and security analysis

• Socket.IO for handling real-time interactions securely

As part of this path, I worked on building five projects including a password cracker. It wasn’t just a technical exercise – it was a way to develop a real security mindset. To understand vulnerabilities, risks, and how attackers think so you can build systems that are stronger and safer.

Then I got into the legacy learning courses:

11: Legacy Certifications

Front End:

Back End:

Data Visualization:

Full Stack:

Legacy Cybersecurity & Quality Assurance:

This phase was incredibly valuable.

It felt like a consolidation of everything I had learned, a chance to revisit key concepts with more maturity and deeper understanding. These certifications focused more on what truly matters in each path, with diverse and practical projects that strengthened both my skills and confidence.

If I had to summarize this entire journey in one idea, it would be this: learning by building changes everything.

This core methodology of freeCodeCamp enabled me to:

• Solve real problems

• Build actual products

• Connect learning with real-world impact

It moved me beyond theory into practice.

Personal Recommendations

Based on my experience, I strongly recommend freeCodeCamp to anyone who wants to:

• Develop programming skills

• Strengthen logical thinking

• Improve problem-solving ability

• Build real-world applications

Because when learning is built on the right methodology, the results are not just visible they are transformative.

Here are resources about freeCodeCamp programs and certifications that structured my learning journey.

Contact Me:

GitHub

Linkedin

X

We (Jess, Carmen, and Eda) are excited to announce the next installation of our free and online bootcamp. We support learners as they work their way through the freeCodeCamp Responsive Web Design curriculum. The bootcamp will start Friday, April 24th, and will run for 10 weeks until Friday, July 3rd.

Here’s what to expect:

• Live Streams: We’ll be streaming Monday to Friday at 15.00 UTC (you can check your timezone here), where we’ll go through the course material together on our YouTube channel, on Jess' Twitch channel and Carmen's Twitch channel. It’s also a chance to ask your questions! If you can’t join us live, the streams will be available offline to watch later.

• Guest Sessions: We’ll expand on our studies with guest sessions where professionals working in software engineering and related fields will talk about their craft.

• Community: To support each other and work together, we have a dedicated Discord channel in the freeCodeCamp Discord server (you can join here: https://discord.gg/KVUmVXA) to help you establish better connections with other learners working on freeCodeCamp material. We’ll also be including shared notes on our website.

• Calendar: We have a shared calendar of lessons we’ll be covering with a supportive and friendly group of learners alongside you.

• Newsletter: There’s no signup needed, but if you want weekly emails, you can also sign up for our newsletter.

How Does the Bootcamp Work?

Bad Website Club bootcamps have been running for a while, so if you've joined us in the past, this one is going to feel a little different.

As the freeCodeCamp course material has expanded, we have adapted our learning structure to reflect what’s in it.

We’re experimenting with a flipped classroom model, where learners do pre-reading and more solo work before classes to come into streamed sessions, prepared to support each other’s learning.

Also, learners will be able to contribute to shared lesson notes which we’ll be going over in unit reviews. We’ll be talking through some (not all!) of the workshop steps and offer space for Q&A in our live streams.

The labs and certification projects need to be done as solo work, but we’ll be looking at how to approach them together on streams and covering them in Q&As.

We’ll be moving fast, but there are no fixed deadlines! If you need more time, your progress will be saved on your freeCodeCamp account. Also, the videos and our Discord are available after the bootcamp ends.

Note that the bootcamp doesn't offer job placement support or 1:1 instructor support for learners due to the size and global distribution of our learners. But we’ll help you learn the skills that prepare you to pursue opportunities on your own.

Who We Are

Bad Website Club has been running free and online developer education programs since 2020. It's run by a small volunteer team (Jessica Rose, Carmen Huidobro, and Eda Eren – also thank you to wonderful Kiri who made all the art!). We focus on learning and experimenting over perfection, and believe that the web can be better when it includes everyone.

Also, it really is free: there’s no way to pay for it.

If you want to join us, you can download or subscribe to the full lesson calendar (for Google Calendar, use the iCal feed with these subscription instructions), follow us on our YouTube channel, on Jess' Twitch channel and Carmen's Twitch channel. You can also sign up for our weekly newsletter for lesson notes, show and tell projects, extra resources, and more.

Hope to see you soon!

The gap between what you tell the computer to do and what you want the computer to do is where bugs are born and thrive.

As a moderator on the freeCodeCamp Discord, I frequently see people pop in to say, “I did everything exactly right but my code isn’t working!” These people know what they want their code to do. But they didn’t tell the computer how to do it properly.

To resolve their bug, they must align their desires — their mental model of their code’s behavior — with their code. Assumptions are the truses that preserve that gap.

The Problem with Assumptions

Let’s say that I'm working on a webpage and I want to set an element’s background to be blue. It’s not working as I desire. It’s setting the text color instead of the background color.

I engage my coworker for help. I say to her, “I told the computer to make the background blue. But it’s setting the text color instead!”

My problem is that I didn’t tell the computer to change the background color. I instead mistakenly used the color property. There’s no way that my coworker could know that I was using the wrong property. So my assumption prevented her from helping me.

The Components of a Great Question

Getting help takes effort. The more work you put into seeking help, the more likely you’ll be to obtain the help you need. In my experience, there are 3 components to a great question when you need technical assistance. Great questions contain all of these components.

1. The code that contains the problem

2. Any error messages you’re seeing

3. A description of the issue containing all of the following:

   • The exact steps to reproduce the issue

   • The expected result

   • The actual result

Below, I’ll break down each component in detail in case you’re not sure how to provide it when asking for help.

The Code that Contains the Problem

This is harder than it sounds. Frequently, the reason I fail to fix a bug by myself is that I’m looking in the wrong place. I may be looking in the wrong function, file, or even project! If I go to my coworker for help and only provide her the code that I think contains the problem, then she may not be able to help me out.

This means that it’s important to provide as much context as possible. This increases the chances that the code you share with the people helping you will contain the information they need to help you solve your problem.

Even with decades of experience coding, I frequently have doubts about how certain code will behave. Being able to run the code and experiment with it (add logs, attach a debugger, try different inputs, and so on) is a big part of my process.

There’s lots of ways you might transmit your code to someone to get some help. Here’s some examples:

For Large Projects

If you’re having trouble with a large project (something more than one file or more than a couple hundred lines of code). Then your best bet is to share a GitHub repo containing all the code.

Alternatively, you might create a “minimal reproduction.” If you can make the problem happen in the context of a small amount of code, then you can share that code instead. This can dramatically reduce the amount of work others need to do to help you and increase your chances of getting the answers you’re seeking.

Note: When working on a project for a client or employer, you might not be able to get help from outside sources due to your inability to share the relevant code. Don't share your employer’s or clients’ code publicly unless you have explicit permission to do so!

For Single File Projects

If your project is just one or two files or you’re creating a minimal reproduction of the issue, then you might be able to in-line your code in a chat message or create a GitHub Gist containing the relevant code.

Alternatively, you could use a tool like CodePen or StackBlitz to quickly generate a reproduction of the problem you’re facing.

For freeCodeCamp Lessons

Many of the questions I get on the freeCodeCamp Discord are regarding lessons in the learning platform (the curriculum). When asking a question about one of these lessons, make sure you include:

1. All the code from the editor panel (that is, all the code you have written or modified)

2. A link to the step

Without these two things, providing help gets dramatically harder.

Error Messages

When you’re a newer developer, error messages can be very intimidating. It’s understandable that you might skim over them as they don’t make sense and you’re not sure how to leverage them to solve your problem.

Reading your error messages carefully can be one of the first steps you take to becoming a stronger developer. But even if you don’t know what to make of the message, when seeking help, make sure you give others with experience in reading those messages the opportunity to do so. If there are any error messages in your console or terminal, copy/paste them in their entirety to your post asking for help.

Description of the Issue

When asking for help, you should consider that the person or people you’re asking might not have any context on your situation. It’s up to you to give them the context they need. To make sure you have given that context, include each of the following:

Steps to Reproduce the Issue

What, specifically, did you do that led you to encounter the problem you have? Be as detailed as possible here. Include things like, “I clicked the ‘Submit’ button,” or “I opened https://www.example.com in my browser.”

The Expected Result

Me: “My text is blue!”
My coworker: “That’s nice.”

My coworker wasn’t being dismissive of my problem. She just didn’t know whether it was a problem or not. Maybe I wanted the text to be blue. Maybe the blue text had nothing to do with my problem. Maybe the text only turns blue under certain circumstances.

If I had told my coworker that I expected the background to be blue rather than the text, she might have quickly realized what I did wrong and offered up a good suggestion on how to fix it.

The Actual result

Me: “I wanted my background to be blue!”
My coworker: “That’s nice.”

Forgetting to give the actual result is pretty much just as useless as forgetting to give the expected result. The expected and actual result of your code are both critical to a well-composed question.

When it comes to sharing actual results, screenshots or videos can be quite handy. Just make sure you’re not relying on them to the exclusion of the other components of a good question.

Example Question

Here’s an example of what putting all this guidance together might yield:

I'm on this step: https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures-v8/learn-introductory-javascript-by-building-a-pyramid-generator/step-33

I tried putting in this code:

for (iterator; condition; iteration) {

}

I expected it to pass, but instead, it gave me an error reading:

ReferenceError: iterator is not defined

Can anyone help me figure out what I'm doing wrong? Here’s a screenshot of the step and error:

The question isn’t long, but it contains all the elements of a quality question as described by this article. It gives the code that contains the problem (including a link to the freeCodeCamp step), the error message that is shown, and the expectations (that it should pass) and actual result (that an error message is shown). It even includes a helpful screenshot showing how the error and result are presented.

Closing Thoughts

This feels like a whole lot of effort. I just want my problem solved. Do I really need to do all of this???

Short answer? Yes. But only because it’s less effort than engaging in a prolonged back and forth as the people trying to help you attempt to get this information. Not just that, but if you go through these steps and collect this information, you might even find that you solve your problem yourself without needing to engage others.

This process might feel tedious at first, but like many things in life, if you practice it regularly then it becomes easier.

You’ve got this. 😎

For my work on circular economy and battery recycling, I needed a way to query multiple databases at once without the manual fatigue.

In this tutorial, you'll build an automated research pipeline using n8n that reduces roughly six hours of manual literature review into a five-minute automated process.

This isn’t a “cool demo workflow.” It’s a production-minded pipeline with parallel collection, normalisation, deduplication, structured AI extraction, scoring, and practical error handling.

Table of Contents

1. Prerequisites

2. The Problem: Research Takes Too Long

3. The Tech Stack

4. The Project Structure: How to Think About an n8n Workflow Like Software

5. Stage 1: Centralised Configuration

6. Stage 2: Parallel API Collection (With Failure Isolation)

7. Stage 3: Normalisation and Deduplication (DOI-first, Title fallback)

8. Stage 4: AI-Powered Content Extraction (Strict JSON)

9. Stage 5: Scoring and Synthesis

10. [Beginner-Friendly Evals (Retrieval and Extraction QA)(#heading-beginnerfriendly-evals-retrieval-and-extraction-qa)

11. Key Learnings and Error Handling

12. Conclusion

Prerequisites

You don’t need to be a DevOps engineer to follow this, but you should have:

• Basic comfort with APIs and JSON (request/response payloads)

• Familiarity with spreadsheets (Google Sheets basics)

• Willingness to use a small amount of JavaScript inside n8n Function/Code nodes

Access to:

• An n8n instance (self-hosted or cloud)

• A Groq API key (or a compatible LLM provider)

• Optional API keys, depending on the databases you use

What you’ll build assumes:

• You’re extracting from metadata + abstracts (not downloading full PDFs).

• You can accept that some sources will occasionally rate-limit or return partial results (and your workflow will be designed to survive this).

The Problem: Research Takes Too Long

Manual research is often a bottleneck for innovation. Before building this automation, my workflow involved searching multiple academic databases, scanning abstracts, and manually extracting key findings. This process was not only slow but also prone to human error and inconsistent note-taking.

The goal of this automation is to provide a “full-stack research assistant” that handles the heavy lifting of collecting candidate papers, removing duplicates, extracting consistent fields, scoring relevance and quality, and delivering a curated daily or weekly report, so you can spend your time on high-level synthesis rather than repetitive collection.

The Tech Stack

This workflow leverages a combination of automation tooling, high-speed LLM inference, and academic metadata providers.

Notes: coverage varies by provider. Some APIs return abstracts reliably, while others may omit them. Your pipeline should treat missing abstracts as a normal case, not a failure.

The Project Structure: How to Think About an n8n Workflow Like Software

While n8n is a visual tool, it helps to design your workflow as modular stages to avoid the “spaghetti workflow” problem.

.
├── configuration/         # Keywords, thresholds, limits, date filters
├── collectors/            # Parallel HTTP request nodes (multiple sources)
├── processing/            # Normalization + deduplication code nodes
├── extraction/            # LLM extraction nodes (strict JSON)
├── scoring/               # Relevance + quality scoring + filtering
└── delivery/              # Google Sheets + email/HTML report

Design principle: each stage should produce a clean, predictable output shape that the next stage can rely on.

Stage 1: Centralised Configuration

Instead of hardcoding search parameters (keywords, min year, citation thresholds) across multiple nodes, use one configuration node to define workflow variables.

This matters for maintainability (change a value once, not in ten nodes), reusability (repurpose the entire pipeline by swapping one config object), and debuggability (log the config at the start of each run so you can reproduce results).

Use a Set node, or a Code node returning JSON like this:

{
  "keywords": "circular economy battery recycling remanufacturing",
  "min_year": 2020,
  "max_results_per_source": 10,
  "min_citations": 2,
  "relevance_threshold": 15,
  "batch_size": 10
}

Tip: keep numeric fields as numbers (not strings) to avoid scoring bugs later.

Stage 2: Parallel API Collection (With Failure Isolation)

Your workflow should query multiple sources simultaneously. In n8n, you can branch from your configuration node into multiple HTTP Request nodes, and then merge results later.

The production mindset here is simple: APIs fail. Rate limits happen. Providers return partial data. The key is to prevent one failing collector from crashing the whole run.

To implement this, on each HTTP Request node, enable Continue On Fail (or the equivalent “don’t stop workflow” behaviour). Then, in the normalisation stage, treat missing or failed outputs as empty arrays so downstream stages still run.

In practice, it also helps to set explicit timeouts and add a small retry policy (one to two retries) for transient failures. “Good” looks like this: if two out of five sources fail, you still produce a useful report from the remaining three, and you log which sources failed so you can investigate later.

Stage 3: Normalisation and Deduplication (DOI-first, Title fallback)

Each academic API returns different field names and shapes. One might use title, another display_name, another paper_title. Your next stage should normalise all inputs into one schema.

Target normalised schema

Here’s a simple baseline schema (expand later as needed):

{
  "title": "string",
  "abstract": "string|null",
  "doi": "string|null",
  "year": 2024,
  "citations": 12,
  "url": "string|null",
  "source": "Semantic Scholar|OpenAlex|arXiv|PubMed"
}

What deduping by DOI means (and what a DOI is)

A DOI (Digital Object Identifier) is a unique, persistent identifier assigned to many scholarly publications. If a paper has a DOI, that DOI functions like a stable ID: the same paper may appear in multiple databases with slightly different metadata, but the DOI should remain consistent.

So, deduping by DOI means: if two records share the same DOI, treat them as the same paper and keep only one.

When a DOI is missing (which is common for some preprints and some API responses), the fallback is to dedupe using a normalised title key, lowercased, trimmed, punctuation stripped, and whitespace collapsed. It’s not as perfect as DOI-based matching, but it’s a strong pragmatic backup.

What “normalise into a unified object” means (what’s happening in the code)

“Normalise into a unified object” simply means converting every provider’s raw response into the same predictable shape (the schema above). Once everything looks the same, downstream steps, such as deduplication, scoring, AI extraction, and storage, become straightforward because they don’t need provider-specific logic.

In the code below, that’s what the normalized object is: it maps Semantic Scholar’s fields (paper.title, paper.externalIds.DOI, paper.citationCount) into your standard fields (title, doi, citations, etc.). After that, the workflow generates a dedupe key (doi:... if DOI exists, otherwise title:...) and uses a Set to keep only the first occurrence.

Example n8n Code Node (Normalisation + Dedupe Pattern)

const itemsIn = $input.all();

const seen = new Set();
const results = [];

function titleKey(t) {
  return (t || "")
    .toLowerCase()
    .replace(/[\W_]+/g, " ")
    .replace(/\s+/g, " ")
    .trim();
}

for (const item of itemsIn) {
  // Example: Semantic Scholar response shape
  const papers = item.json?.data || [];

  for (const paper of papers) {
    // "Normalize into a unified object":
    // take the provider-specific fields and map them into our standard schema.
    const normalized = {
      title: paper.title || null,
      abstract: paper.abstract || null,
      doi: paper.externalIds?.DOI || null,
      year: paper.year || null,
      citations: paper.citationCount || 0,
      url: paper.url || null,
      source: "Semantic Scholar",
    };

    if (!normalized.title) continue;

    // Dedupe key: DOI is strongest; title is fallback
    const key = normalized.doi
      ? `doi:${normalized.doi.toLowerCase()}`
      : `title:${titleKey(normalized.title)}`;

    if (seen.has(key)) continue;
    seen.add(key);

    results.push(normalized);
  }
}

return results.map(r => ({ json: r }));

Production-minded note: keep a field like source so you can debug where bad metadata is coming from later.

Stage 4: AI-Powered Content Extraction (Strict JSON)

Once you have a deduplicated list of papers, you can send each paper (or a small batch) to Groq for structured extraction.

Why structured output matters

If your LLM returns narrative text instead of JSON, misses fields, or emits malformed JSON, your workflow breaks downstream. In a production workflow, that’s not a rare edge case; it’s something you should expect and design around.

That’s why you’ll use strict schema prompting and validate responses downstream.

System prompt vs user prompt (and how to compose them)

A helpful way to think about prompts in production is:

• The system prompt defines the non-negotiable contract: output format, allowed keys, no commentary, and what to do in uncertain cases. This is where you say “return ONLY valid JSON” and “no extra keys.”

• The user prompt provides the variable data for this specific request: title, year, citations, abstract, and the exact schema you want filled.

Composing them this way keeps your workflow stable. The system prompt stays mostly constant (your formatting contract), while the user prompt changes per paper (your payload). It also makes debugging easier: if outputs start failing, you can adjust the system constraints without rewriting every payload template.

Suggested extraction schema

Extract only what you can support from abstract-level data:

• research_question

• methodology

• key_findings

• limitations

• notes (for missing abstract / ambiguity)

Example prompt (system + user)

System:

You are a research extraction engine. You must return ONLY valid JSON.
No markdown. No extra keys. No commentary.
If the abstract is missing or too vague, set fields to null and include a reason in "notes".

User:

Extract structured fields from this paper.

TITLE: {{title}}
YEAR: {{year}}
CITATIONS: {{citations}}
ABSTRACT: {{abstract}}

Return JSON with keys:
research_question (string|null)
methodology (string|null)
key_findings (array of strings)
limitations (array of strings)
notes (string)

Model settings: keep temperature low (around 0.2–0.3) and keep responses short and structured.

Batch processing to avoid timeouts

Instead of sending 50 papers at once, process them in batches (for example, 10). This reduces latency spikes, failure blast radius, and cost surprises. Smaller batches also make it easier to retry only the failing chunk rather than re-running everything.

Stage 5: Scoring and Synthesis

Not every retrieved paper is worth your time. Without scoring, your pipeline becomes a firehose: you’ve automated collection, but you still have to manually decide what to read. Scoring is what turns “a big list of results” into a shortlist you can trust.

I recommend computing two signals:

• Relevance: Is this actually about your research question?

• Quality/priority: If it’s relevant, is it worth reading first?

For relevance, keep it simple and explainable. Count keyword hits in the title and abstract (and optionally in extracted key_findings). Title matches should be weighted higher because titles are deliberately compact summaries. Abstract hits are useful too, but cap them so long abstracts don’t dominate the score.

For quality/priority, use lightweight metadata you already have. Recency is a strong signal in fast-moving areas, and citations can help, but they should be treated as a weak signal (and capped) so newer high-value papers aren’t unfairly penalised.

A solid first scoring model is: add a title bonus, add a capped abstract bonus, add a capped citations bonus, and add a small recency bonus for papers from the last two years. Then filter using the relevance_threshold results from Stage 1. The advantage of this approach is that it’s easy to debug and tune: you can always explain why a paper passed or failed.

Once you’ve filtered down to your “gold” set, synthesis becomes safer and more useful. Write one row per accepted paper to Google Sheets, then generate a daily/weekly HTML summary (for example, top 5 papers with 1–2 key findings each) and include links so you can verify quickly.

Beginner-Friendly Evals: Retrieval and Extraction QA

AI workflows regress silently. A prompt tweak, a model update, or an API schema change can break extraction without throwing an obvious error. Adding lightweight evals is the difference between “it worked last week” and “it’s reliable.”

The goal here isn’t to build a full evaluation framework. It’s to add small, cheap checks that catch the most common failure modes:

• Are collectors still returning results?

• Are we actually removing duplicates?

• Is the LLM returning valid JSON with the keys we require?

What it looks like in n8n (a concrete example)

A simple implementation is to add an “Assertions” Code node immediately after your extraction step, plus (optionally) another one after normalisation/deduplication.

At a high level, the workflow section looks like:

1. Collectors (parallel HTTP Request nodes)

2. Merge results

3. Normalise + dedupe (Code node)

4. Split in Batches (optional)

5. LLM extraction (Groq/OpenAI-compatible node)

6. Assertions (Code node)

7. If node (pass/fail)

8. Delivery (Sheets + email)

Example: Assertions code node after extraction

This code node assumes each item is a paper with:

• title, abstract in the normalised fields, and

• an extraction field (or whatever you name it) containing the LLM response as an object or JSON string.

Adapt the field name to match your actual node output, but the pattern is the same: parse, validate required keys, compute percentages, then decide whether to fail or warn.

const items = $input.all();

let total = items.length;
let withTitle = 0;
let withAbstract = 0;

let parseOk = 0;
let schemaOk = 0;

const requiredKeys = [
  "research_question",
  "methodology",
  "key_findings",
  "limitations",
  "notes",
];

const failures = [];

for (let i = 0; i < items.length; i++) {
  const p = items[i].json;

  if (p.title && String(p.title).trim().length > 0) withTitle++;
  if (p.abstract && String(p.abstract).trim().length > 0) withAbstract++;

  // Adjust this depending on where you store the model output:
  const raw = p.extraction ?? p.llm ?? p.model_output;

  let obj = null;
  try {
    obj = typeof raw === "string" ? JSON.parse(raw) : raw;
    parseOk++;
  } catch (e) {
    failures.push({ index: i, title: p.title || null, reason: "JSON parse failed" });
    continue;
  }

  const hasAllKeys = requiredKeys.every(k => Object.prototype.hasOwnProperty.call(obj, k));
  if (!hasAllKeys) {
    failures.push({ index: i, title: p.title || null, reason: "Missing required keys" });
    continue;
  }

  // Optional: ensure arrays are arrays
  const arraysOk = Array.isArray(obj.key_findings) && Array.isArray(obj.limitations);
  if (!arraysOk) {
    failures.push({ index: i, title: p.title || null, reason: "key_findings/limitations not arrays" });
    continue;
  }

  schemaOk++;
}

const pct = (n) => (total === 0 ? 0 : Math.round((n / total) * 100));

const report = {
  total_papers: total,
  pct_with_title: pct(withTitle),
  pct_with_abstract: pct(withAbstract),
  pct_extraction_json_parse_ok: pct(parseOk),
  pct_extraction_schema_ok: pct(schemaOk),
  failures_sample: failures.slice(0, 5),
};

// Decide pass/fail thresholds
const HARD_FAIL_PARSE_BELOW = 90;
const HARD_FAIL_SCHEMA_BELOW = 85;

const shouldFail =
  report.pct_extraction_json_parse_ok < HARD_FAIL_PARSE_BELOW ||
  report.pct_extraction_schema_ok < HARD_FAIL_SCHEMA_BELOW;

return [
  {
    json: {
      eval_report: report,
      shouldFail,
    },
  },
];

Then add an If node:

• If shouldFail is true, then route to an “Alert/Stop” branch (Slack/email/log) and optionally stop the workflow.

• If false, then continue to the delivery stage.

This is the automation equivalent of unit tests: small, cheap, and extremely effective. It also gives you a concrete paper trail when something changes upstream.

Key Learnings and Error Handling

Building this automation taught me that the best workflows are designed for failure.

First, error resilience is not optional. Never let one failing API crash the workflow. Use “Continue On Fail” on your HTTP nodes, merge partial results, and log which sources failed in your final report so you can debug without losing an entire run.

Second, batching is your friend. Process papers in batches (often 5–15) to reduce timeouts and cost spikes. Keep LLM payloads small and focused on what you actually need (metadata + abstract), and retry transient failures once rather than repeatedly hammering the model or API.

Third, structured prompting is what makes AI reliable in automation. A strict JSON schema is the difference between a workflow that runs unattended and one that breaks randomly. Keep temperature low, enforce the schema in the system prompt, and validate everything downstream with simple parse-and-assert checks.

Conclusion

A good research pipeline doesn’t just retrieve papers – it turns scattered results into a consistent, deduplicated, scored, and review-ready shortlist you can trust.

By treating your n8n workflow like software modular stages, strict contracts between steps, and lightweight eval checks, you can reduce hours of manual literature review into a fast, repeatable process that survives real-world API failures and model quirks.

If you build this with good defaults (failure isolation, batching, normalisation, strict JSON extraction, and simple scoring), you end up with something you can run daily or weekly and actually rely on without the manual fatigue.

About Me

I am Chidozie Managwu, an award-winning AI Product Architect and founder focused on helping global tech talent build real, production-ready skills. I contribute to global AI initiatives as a GAFAI Delegate and lead the AI Titans Network, a community for developers learning how to ship AI products.

My work has been recognised with the Global Tech Hero award and featured on platforms like HackerNoon.

Each chapter includes hundreds of interactive tasks designed to help you take your first steps in learning Chinese with confidence.

How Does the New A1 Professional Chinese Curriculum Work?

In this A1 Professional Chinese Curriculum, you'll learn the building blocks of the Chinese language. This will follow the A1 level of the Common European Framework of Reference (CEFR). And we've focused on vocabulary that is particularly useful for professional settings.

The curriculum is broken down into several modules that include warm-up, learning, practice, review pages, and quizzes to make sure that you truly understand the material before moving onto the next module.

The Warm-up serves as preparation and provides context for the main content of the module.

The tasks in the warm-up will either introduce you to new vocabulary for the first time, or review content you have already learned that will be used in the current module.

Below is an example of what you will find in the lessons.

Each task will have an accompanying question that will help you practice the content. If you don’t know how to answer a question or need more details, you can check the explanation section.

After the Warm-up, you'll head over to Learn. This is where you'll see the new words you've learned in action! You'll listen to short sections of monologues or dialogues and answer questions about them to make sure you understand their meaning and how they're used in real conversations. This is also where you’ll learn some theory when needed.

The curriculum also has fill-in-the-blank questions that will help you practice writing using Pinyin and Hanzi.

After Learn, you'll move on to Practice where you'll complete more open-ended tasks that test your comprehension and your ability to write using Pinyin and Hanzi.

At the end of each module, there is a Review section with grammar highlights and a glossary of the main points and concepts covered. You can use these review pages to help you study for the quizzes.

The last portion of the module is the Quiz. Quizzes are designed to test your understanding from the material covered in the module.

Throughout the certification, each chapter will have these quizzes. You’ll need to complete them in order to qualify for the exam at the end of the certification.

The certification exam will be the final item released for this certification. We are currently publishing the first three chapters, and future chapters will be released progressively as they are developed by our instructional design team. Once all the chapters are available, we will release the certification exam.

Contributors recognition

We'd like to shout out to the following contributors for their help in developing the curriculum:

• Krzysztof G.

• Chen Guo Zheng

• Steven Ding

We'd like to extend a special thanks to S1ng S1ng, who has recorded the monologues and dialogues audios, and has also recorded instructional videos that vividly demonstrate Pinyin pronunciation. These Pinyin videos will be gradually added to the curriculum throughout the coming year.

Frequently Asked Questions

Is all of this really free?

Yes. freeCodeCamp has always been free, and we've now offered free verified certifications for more than a decade.

Can I study the Chinese curriculum in languages other than English?

We aim to make every course available in all supported languages on freeCodeCamp. Check your account settings to see if the course you are studying is already offered in your preferred language.

What language skills does the Chinese curriculum cover?

The languages courses currently cover listening, reading and writing. We have plans of adding speaking later on.

Are the audio in the language courses and exams recorded by native language speakers?

Yes. All the audios present in the language courses were recorded by native speakers of that language.

I am Deaf or hard of hearing. Can I still study the language courses?

Yes! All audio lesson have closed captions and transcripts available for reading.

I am blind or have limited vision, and use a screen reader. Can I still study the language courses?

Yes! freeCodeCamp courses are designed to be accessible, and you can study the language courses using a screen reader. If you run into any accessibility issues, you can report them on our GitHub repository so the community can address them.

What are the letters and numbers beside the curriculum names? (For example: A1, A2, B1)

These labels refer to the CEFR levels, which is an international framework used to describe language proficiency. A1 and A2 represent beginner levels, B1 and B2 represent intermediate levels, and C1 and C2 represent advanced levels. Each level indicates the skills and knowledge you are expected to have at that stage of your language learning journey.

Anything else?

Good luck working through freeCodeCamp’s languages coursework.

Happy learning!

Each certification is filled with hundreds of hours worth of interactive lessons, workshops, labs, and quizzes.

How Does the New Relational Databases Certification Work?

The new Relational Databases certification will teach you core concepts including Bash scripting, SQL, Git, and more.

The certification is broken down into several modules that include lessons, workshops, labs, review pages, and quizzes to ensure that you truly understand the material before moving onto the next module.

The lessons are your first exposure to new concepts. They provide crucial theory and context for how things work in the software development industry.

At the end of each lesson, there will be three comprehension check questions to test your understanding of the material from the lesson.

After the lesson blocks, you will do the workshops. These workshops are guided step-based projects that provide you with an opportunity to practice what you have learned in the lessons.

These workshops will not be done inside the regular freeCodeCamp editor in the browser. Instead you will need to do these workshops in one of three environments:

• GitHub Codespaces: This course runs in a virtual Linux machine using GitHub Codespaces.

• Your own local environment: This course runs in a virtual Linux machine on your computer.

• Ona: This course runs in a virtual Linux machine using Ona.

After the workshop, you will complete a lab which will help you review what you have learned so far. This will give you chance to start building projects on your own, which is a crucial skill for a developer. You will be presented with a list of users stories and will need to pass the tests to complete the lab.

At the end of each module, there is a review page containing a list of all of the concepts covered. You can use these review pages to help you study for the quizzes.

The last portion of the module is the quiz. This is a 20 question multiple choice quiz designed to test your understanding from the material covered in the module. You will need to get 18 out of 20 correct to pass.

Throughout the certification, there will be five certification projects you will need to complete in order to qualify for the exam.

Once you’ve completed all 5 certification projects, you’ll be able to take the 50 question exam using our new open source exam environment. The freeCodeCamp community designed this exam environment tool with two goals: respecting your privacy while also making it harder for people to cheat.

Once you download the app to your laptop or desktop, you can take the exam.

Frequently Asked Questions

Is all of this really free?

Yes. freeCodeCamp has always been free, and we’ve now offered free verified certifications for more than a decade. These exams are just the latest expansion to our community’s free learning resources.

What prevents people from just cheating on the exams?

Our goal is to strike a balance between preventing cheating and respecting people's right to privacy.

We've implemented a number of reliable, yet non-invasive, measures to help prevent people from cheating on freeCodeCamp's exams:

1. For each exam, we have a massive bank of questions and potential answers to those questions. Each time a person attempts an exam, they'll see only a small, randomized sampling of these questions.

2. We only allow people to attempt an exam one time per week. This reduces their ability to "brute force" the exam.

3. We have security in place to validate exam submissions and prevent man-in-the-middle attacks or manipulation of the exam environment.

4. We manually review each passing exam for evidence of cheating. Our exam environment produces tons of metrics for us to draw from.

We take cheating, and any form of academic dishonesty, seriously. We will act decisively.

This said, no one's exam results will be thrown out without human review, and no one's account will be banned without warning based on a single suspicious exam result.

Are these exams “open book” or “closed book”?

All of freeCodeCamp’s exams are “closed book”, meaning you must rely only on your mind and not outside resources.

Of course, in the real world you’ll be able to look things up. And in the real world, we encourage you to do so.

But that is not what these exams are evaluating. These exams are instead designed to test your memory of details and your comprehension of concepts.

So when taking these exams, do not use outside assistance in the form of books, notes, AI tools, or other people. Use of any of these will be considered academic dishonesty.

Do you record my webcam, microphone, or require me to upload a photo of my personal ID?

No. We considered adding these as additional test-taking security measures. But we have less privacy-invading methods of detecting most forms of academic dishonesty.

If the environment is open source, doesn't that make it less secure?

"Given enough eyeballs, all bugs are shallow." – Linus’s Law, formulated by Eric S. Raymond in his book The Cathedral and the Bazaar

Open source software projects are often more secure than their closed source equivalents. This is because a lot more people are scrutinizing the code. And a lot more people can potentially help identify bugs and other deficiencies, then fix them.

We feel confident that open source is the way to go for this exam environment system.

How can I contribute to the Exam Environment codebase?

It's fully open source, and we'd welcome your code contributions. Please read our general contributor onboarding documentation.

Then check out the GitHub repo.

You can help by creating issues to report bugs or request features.

You can also browse open help wanted issues and attempt to open pull requests addressing them.

Are the exam questions themselves open source?

For obvious exam security reasons, the exam question banks themselves are not publicly accessible. :)

These are built and maintained by freeCodeCamp's staff instructional designers.

What happens if I have internet connectivity issues mid-exam?

If you have internet connectivity issues mid exam, the next time you try submit an answer, you’ll be told there are connectivity issues. The system will keep prompting you to retry submitting until the connection succeeds.

What if my computer crashes mid-exam?

If your computer crashes mid exam, you’ll be able to re-open the Exam Environment. Then, if you still have time left for your exam attempt, you’ll be able to continue from where you left off.

Can I take exams in languages other than English?

Not yet. We’re working to add multi-lingual support in the future.

I have completed my exam. Why can't I see my results yet?

All exam attempts are reviewed by freeCodeCamp staff before we release the results. We do this to ensure the integrity of the exam process and to prevent cheating. Once your attempt has been reviewed, you'll be notified of your results the next time you log in to freeCodeCamp.org.

I am Deaf or hard of hearing. Can I still take the exams?

Yes! While some exams may include audio components, we do make written transcripts available for reading.

I am blind or have limited vision, and use a screen reader. Can I still take the exams?

We’re working on it. Our curriculum is fully screen reader accessible. We're still refining our screen reader usability for the Exam Environment app. This is a high priority for us.

I use a keyboard instead of a mouse. Can I navigate the exams using just a keyboard?

This is a high priority for us. We hope to add keyboard navigation to the Exam Environment app soon.

Are exams timed?

Yes, exams are timed. We err on the side of giving plenty of time to take the exam, to account for people who are non-native English speakers, or who have ADHD and other learning differences that can make timed exams more challenging.

If you have a condition that usually qualifies you for extra time on standardized exams, please email support@freecodecamp.org. We’ll review your request and see whether we can find a reasonable solution.

What happens if I fail the exam? Can I retake it?

Yes. You get one exam attempt per week. After you attempt an exam, there is a one-week (exactly 168 hour) “cool-down” period where you cannot take any freeCodeCamp exams. This is to encourage you to study and to pace yourself.

There is no limit to the number of times you can take an exam. So if you fail, study more, practice your skills more, then try again the following week.

Do I need to redo the projects if I fail the exam?

No. Once you’ve submitted a certification project, you do not need to ever submit it again.

You can re-do projects for practice, but we recommend that you instead build some of our many practice projects in freeCodeCamp’s developer interview job search section.

What happens if I already have the old Legacy Responsive Web Design certification? Should I claim the new one?

The new certification has more theory and practice as well as an exam. So if you’re looking to brush up on your skills, then you can go through the new version of this certification.

What will happen to my existing coursework progress on the Full Stack Certification? Does it transfer over to the Responsive Web Design course?

If you’ve already started the Certified Full Stack Developer Curriculum, all of your previously completed work should already be saved there.

To be clear, we’ve copied over all of the coursework from the full stack certification to this newer certification.

Can I still continue with the current Full Stack Developer Certification and just not do the new certification?

We’ve moved the coursework for the Full Stack Developer Certification over and broken it up into smaller certifications. Currently there are seven courses available for you to go through. Here is the complete list:

• Responsive Web Design Certification

• JavaScript Certification

• Frontend Libraries Certification

• Python Certification

• Relational Databases Certification

• Backend JavaScript Certification

• Certified Full Stack Developer Certification

The Certified Full Stack Developer Certification button will remain on the learn page for a short time to give people the opportunity to switch over to the new certifications. Over the next few months, though, this option will disappear.

Will my legacy certifications become invalid?

No. Once you claim a certification, it’s yours to keep.

Also note that we previously announced that freeCodeCamp certifications would have an expiration date and require recertification. We don’t plan to implement this anytime soon. And if we do decide to, we will give everyone at least a year’s notice.

Will the exam be available to take on my phone?

At this time, no. You’ll need to use a laptop or desktop to download the exam environment and take the exam. We hope to eventually offer these certification exams on iPhone and Android.

I have a disability or health condition that is not covered here. How can I request accommodations?

If you need specific accommodations for the exam (for example extra time, breaks, or alternative formats), please email support@freecodecamp.org. We’ll review your request and see whether we can find a reasonable solution.

Anything else?

Good luck working through freeCodeCamp’s coursework, building projects, and preparing for these exams.

Happy coding!

How Does the B1 English for Developers Certification Work?

This Intermediate level English for Developers Curriculum will help you strengthen the foundational skills developed in the A2 English for developers certification while introducing more complex grammar and expanding on work-related topics.

This entire curriculum will follow the B1 level of the Common European Framework of Reference (CEFR). And, as always, we've focused on vocabulary that is particularly useful for developers.

You'll learn how to describe places and things, share past experiences, and confidently use tenses like Present Perfect and Future. Practical communication strategies are included as well, such as managing conversations, expressing opinions, and building agreement or disagreement in discussions.

You'll also practice vocabulary and phrases essential for developers, such as describing code, participating in meetings, and discussing tech trends. Advanced topics include conditionals, comparative structures, and conversation management, so you can prepare for more complex interactions.

This entire B1-level curriculum includes 73 different dialogues recorded by native English speakers. Each section follows a unique theme, contains several dialogues, and is filled with hundreds of interactive tasks that will help you develop your English skills.

These tasks will introduce new vocabulary, teach grammar, or review concepts that you’ll need to know in order to understand what the characters from the dialogues are saying. Each task will have an accompanying question that will help you practice the content.

The curriculum also has fill-in-the-blank questions that will help you practice writing in English.

Once you’ve completed the certification, you’ll be able to take the B1 English for Developers exam. This exam contains 54 grammar questions, 24 listening questions, and 9 reading questions. All the questions are based on what’s covered in the certification course.

You can take the exam by using our new open source exam environment. The freeCodeCamp community designed this exam environment tool with two goals in mind: respecting your privacy while also making it harder for people to cheat.

Once you download the app to your laptop or desktop, you can take the exam.

Frequently Asked Questions

Is all of this really free?

Yes. freeCodeCamp has always been free, and we’ve now offered free verified certifications for more than a decade. These exams are just the latest expansion to our community’s free learning resources.

Can I study the certification courses in languages other than English?

We aim to make every course available in all supported languages on freeCodeCamp. Check your account settings to see if the course you are studying is already offered in your preferred language.

What language skills does the curriculum cover?

The languages courses currently cover listening, reading, and writing. We have plans to add speaking later on.

Are the audio in the language courses and exams recorded by native language speakers?

Yes. All the audios present in the language courses were recorded by native speakers of that language.

I am Deaf or hard of hearing. Can I still study the language courses?

Yes! All audio lesson have closed captions and transcripts available for reading.

I am blind or have limited vision, and use a screen reader. Can I still study the language courses?

Yes! freeCodeCamp courses are designed to be accessible, and you can study the language courses using a screen reader. If you run into any accessibility issues, you can report them on our GitHub repository so the community can address them.

What are the letters and numbers beside the certification name? (For example: A1, A2, B1)

These labels refer to the CEFR levels, which is an international framework used to describe language proficiency. A1 and A2 represent beginner levels, B1 and B2 represent intermediate levels, and C1 and C2 represent advanced levels.

Each level indicates the skills and knowledge you are expected to have at that stage of your language learning journey.

What prevents people from just cheating on the exams?

Our goal is to strike a balance between preventing cheating and respecting people's right to privacy.

We've implemented a number of reliable, yet non-invasive, measures to help prevent people from cheating on freeCodeCamp's exams:

1. For each exam, we have a massive bank of questions and potential answers to those questions. Each time a person attempts an exam, they'll see only a small, randomized sampling of these questions.

2. We only allow people to attempt an exam one time per week. This reduces their ability to "brute force" the exam.

3. We have security in place to validate exam submissions and prevent man-in-the-middle attacks or manipulation of the exam environment.

4. We manually review each passing exam for evidence of cheating. Our exam environment produces tons of metrics for us to draw from.

We take cheating, and any form of academic dishonesty, seriously. We will act decisively.

This said, no one's exam results will be thrown out without human review, and no one's account will be banned without warning based on a single suspicious exam result.

Are these exams “open book” or “closed book”?

All of freeCodeCamp’s exams are “closed book”, meaning you must rely only on your mind and not outside resources.

Of course, in the real world you’ll be able to look things up. And in the real world, we encourage you to do so.

But that is not what these exams are evaluating. These exams are instead designed to test your memory of details and your comprehension of concepts.

So when taking these exams, do not use outside assistance in the form of books, notes, AI tools, or other people. Use of any of these will be considered academic dishonesty.

Do you record my webcam, microphone, or require me to upload a photo of my personal ID?

No. We considered adding these as additional test-taking security measures. But we have less privacy-invading methods of detecting most forms of academic dishonesty.

If the environment is open source, doesn't that make it less secure?

"Given enough eyeballs, all bugs are shallow." – Linus’s Law, formulated by Eric S. Raymond in his book The Cathedral and the Bazaar

Open source software projects are often more secure than their closed source equivalents. This is because a lot more people are scrutinizing the code. And a lot more people can potentially help identify bugs and other deficiencies, then fix them.

We feel confident that open source is the way to go for this exam environment system.

How can I contribute to the Exam Environment codebase?

It's fully open source, and we'd welcome your code contributions. Please read our general contributor onboarding documentation.

Then check out the GitHub repo.

You can help by creating issues to report bugs or request features.

You can also browse open help wanted issues and attempt to open pull requests addressing them.

Are the exam questions themselves open source?

For obvious exam security reasons, the exam question banks themselves are not publicly accessible. :)

These are built and maintained by freeCodeCamp's staff instructional designers.

What happens if I have internet connectivity issues mid-exam?

If you have internet connectivity issues mid exam, the next time you try to submit an answer, you’ll be told there are connectivity issues. The system will keep prompting you to retry submitting until the connection succeeds.

What if my computer crashes mid-exam?

If your computer crashes mid exam, you’ll be able to re-open the Exam Environment. Then, if you still have time left for your exam attempt, you’ll be able to continue from where you left off.

Can I take exams in languages other than English?

Not yet. We’re working to add multi-lingual support in the future.

I have completed my exam. Why can't I see my results yet?

All exam attempts are reviewed by freeCodeCamp staff before we release the results. We do this to ensure the integrity of the exam process and to prevent cheating. Once your attempt has been reviewed, you'll be notified of your results the next time you log in to freeCodeCamp.org.

I use a keyboard instead of a mouse. Can I navigate the exams using just a keyboard?

This is a high priority for us. We hope to add keyboard navigation to the Exam Environment app soon.

Are exams timed?

Yes, exams are timed. We err on the side of giving plenty of time to take the exam, to account for people who are non-native English speakers, or who have ADHD and other learning differences that can make timed exams more challenging.

If you have a condition that usually qualifies you for extra time on standardized exams, please email support@freecodecamp.org. We’ll review your request and see whether we can find a reasonable solution.

What happens if I fail the exam? Can I retake it?

Yes. You get one exam attempt per week. Afterward, if you don’t pass, there is a one-week (exactly 168 hour) “cool-down” period where you cannot take any freeCodeCamp exams. This is to encourage you to study and to pace yourself.

There is no limit to the number of times you can take an exam. So if you fail, study more, practice your skills more, then try again the following week.

Will the exam be available to take on my phone?

At this time, no. You’ll need to use a laptop or desktop to download the exam environment and take the exam. We hope to eventually offer these certification exams on iPhone and Android.

I have a disability or health condition that is not covered here. How can I request accommodations?

If you need specific accommodations for the exam (for example extra time, breaks, or alternative formats), please email support@freecodecamp.org. We’ll review your request and see whether we can find a reasonable solution.

Anything else?

Good luck working through freeCodeCamp’s languages coursework and preparing for the exam.

Happy learning!

How Does the New A1 Professional Spanish Curriculum Work?

In this A1 Professional Spanish Curriculum, you'll learn the building blocks of the Spanish language. It follows the A1 level of the Common European Framework of Reference (CEFR). And we've focused on vocabulary that is particularly useful for professional settings.

The curriculum is broken down into several modules that include warm-up, learning, practice, review pages, and quizzes to make sure that you truly understand the material before moving onto the next module.

The warm-up serves as preparation and provides context for the main content of the module.

The tasks in the warm-up will either introduce you to new vocabulary for the first time, or review content you have already learned that will be used in the current module.

Below is an example of what you will find in the lessons:

Each task will have an accompanying question that will help you practice the content. If you don’t know how to answer a question or need more details, you can check the explanation section below the question.

After the warm-up, you’ll head over to Learn. This is where you’ll see the new words you’ve learned in action! You'll listen to short sections of monologues or dialogues and answer questions about them to make sure you understand their meaning and how they're used in real conversations. This is also where you’ll learn some theory when needed.

The curriculum also has fill-in-the-blank questions that will help you practice writing in Spanish.

After Learn, you’ll move on to Practice where you'll complete more open-ended tasks that test your comprehension and your ability to write in Spanish.

At the end of each module, there is a Review section with grammar highlights and a glossary of the main points and concepts covered. You can use these review pages to help you study for the quizzes.

The last portion of the module is the Quiz. Quizzes are designed to test your understanding from the material covered in the module.

Throughout the certification, each chapter will have these quizzes. You’ll need to complete them in order to qualify for the exam at the end of the certification.

The certification exam will be the final item released for this certification. We are currently publishing the first three chapters, and future chapters will be released progressively as they are developed by our instructional design team. Once all the chapters are available, we will release the certification exam.

Frequently Asked Questions

Is all of this really free?

Yes. freeCodeCamp has always been free, and we’ve now offered free verified certifications for more than a decade.

Can I study the Spanish curriculum in languages other than English?

We aim to make every course available in all supported languages on freeCodeCamp. Check your account settings to see if the course you are studying is already offered in your preferred language.

What language skills does the Spanish curriculum cover?

The languages courses currently cover listening, reading, and writing. We have plans to add speaking later on.

Are the audio in the language courses and exams recorded by native language speakers?

Yes. All the audio lessons present in the language courses were recorded by native speakers of that language.

I am Deaf or hard of hearing. Can I still study the language courses?

Yes! All audio lesson have closed captions and transcripts available for reading.

I am blind or have limited vision, and use a screen reader. Can I still take the language courses?

Yes! freeCodeCamp courses are designed to be accessible, and you can take the language courses using a screen reader. If you run into any accessibility issues, you can report them on our GitHub repository so the community can address them.

What are the letters and numbers after the curriculum name? (For example: A1, A2, B1)

These labels refer to the CEFR levels, which is an international framework used to describe language proficiency. A1 and A2 represent beginner levels, B1 and B2 represent intermediate levels, and C1 and C2 represent advanced levels. Each level indicates the skills and knowledge you are expected to have at that stage of your language learning journey.

Anything else?

Good luck working through freeCodeCamp’s languages coursework.

Happy learning!

Each certification is filled with hundreds of hours worth of interactive lessons, workshops, labs, and quizzes.

How Does the New Python Certification Work?

The new Python certification will teach you core concepts including functions, loops, dictionaries, sets, classes, data structures, algorithms, and more.

The certification is broken down into several modules that include lessons, workshops, labs, review pages, and quizzes to ensure that you truly understand the material before moving onto the next module.

The lessons are your first exposure to new concepts. They provide crucial theory and context for how things work in the software development industry.

At the end of each lesson, there will be three comprehension check questions to test your understanding of the material from the lesson.

After the lesson blocks, you will do the workshops. These workshops are guided step-based projects that provide you with an opportunity to practice what you have learned in the lessons.

You do not need to install a separate application to run your Python code. We have a custom Python editor that runs Python code in the browser.

After the workshops, you will complete a lab which will help you review what you have learned so far. This will give you chance to start building projects on your own, which is a crucial skill for a developer. You will be presented with a list of users stories and will need to pass the tests to complete the lab

At the end of each module, there is a review page containing a list of all of the concepts covered. You can use these review pages to help you study for the quizzes.

The last portion of the module is the quiz. This is a 20 question multiple choice quiz designed to test your understanding from the material covered in the module. You will need to get 18 out of 20 correct to pass.

Throughout the certification, there will be five certification projects you will need to complete in order to qualify for the exam.

Once you’ve completed all 5 certification projects, you’ll be able to take the 50 question exam using our new open source exam environment. The freeCodeCamp community designed this exam environment tool with two goals: respecting your privacy while also making it harder for people to cheat.

Once you download the app to your laptop or desktop, you can take the exam.

Frequently Asked Questions

Is all of this really free?

Yes. freeCodeCamp has always been free, and we’ve now offered free verified certifications for more than a decade. These exams are just the latest expansion to our community’s free learning resources.

What prevents people from just cheating on the exams?

Our goal is to strike a balance between preventing cheating and respecting people's right to privacy.

We've implemented a number of reliable, yet non-invasive, measures to help prevent people from cheating on freeCodeCamp's exams:

1. For each exam, we have a massive bank of questions and potential answers to those questions. Each time a person attempts an exam, they'll see only a small, randomized sampling of these questions.

2. We only allow people to attempt an exam one time per week. This reduces their ability to "brute force" the exam.

3. We have security in place to validate exam submissions and prevent man-in-the-middle attacks or manipulation of the exam environment.

4. We manually review each passing exam for evidence of cheating. Our exam environment produces tons of metrics for us to draw from.

We take cheating, and any form of academic dishonesty, seriously. We will act decisively.

This said, no one's exam results will be thrown out without human review, and no one's account will be banned without warning based on a single suspicious exam result.

Are these exams “open book” or “closed book”?

All of freeCodeCamp’s exams are “closed book”, meaning you must rely only on your mind and not outside resources.

Of course, in the real world you’ll be able to look things up. And in the real world, we encourage you to do so.

But that is not what these exams are evaluating. These exams are instead designed to test your memory of details and your comprehension of concepts.

So when taking these exams, do not use outside assistance in the form of books, notes, AI tools, or other people. Use of any of these will be considered academic dishonesty.

Do you record my webcam, microphone, or require me to upload a photo of my personal ID?

No. We considered adding these as additional test-taking security measures. But we have less privacy-invading methods of detecting most forms of academic dishonesty.

If the environment is open source, doesn't that make it less secure?

"Given enough eyeballs, all bugs are shallow." – Linus’s Law, formulated by Eric S. Raymond in his book The Cathedral and the Bazaar

Open source software projects are often more secure than their closed source equivalents. This is because a lot more people are scrutinizing the code. And a lot more people can potentially help identify bugs and other deficiencies, then fix them.

We feel confident that open source is the way to go for this exam environment system.

How can I contribute to the Exam Environment codebase?

It's fully open source, and we'd welcome your code contributions. Please read our general contributor onboarding documentation.

Then check out the GitHub repo.

You can help by creating issues to report bugs or request features.

You can also browse open help wanted issues and attempt to open pull requests addressing them.

Are the exam questions themselves open source?

For obvious exam security reasons, the exam question banks themselves are not publicly accessible. :)

These are built and maintained by freeCodeCamp's staff instructional designers.

What happens if I have internet connectivity issues mid-exam?

If you have internet connectivity issues mid exam, the next time you try submit an answer, you’ll be told there are connectivity issues. The system will keep prompting you to retry submitting until the connection succeeds.

What if my computer crashes mid-exam?

If your computer crashes mid exam, you’ll be able to re-open the Exam Environment. Then, if you still have time left for your exam attempt, you’ll be able to continue from where you left off.

Can I take exams in languages other than English?

Not yet. We’re working to add multi-lingual support in the future.

I have completed my exam. Why can't I see my results yet?

All exam attempts are reviewed by freeCodeCamp staff before we release the results. We do this to ensure the integrity of the exam process and to prevent cheating. Once your attempt has been reviewed, you'll be notified of your results the next time you log in to freeCodeCamp.org.

I am Deaf or hard of hearing. Can I still take the exams?

Yes! While some exams may include audio components, we do make written transcripts available for reading.

I am blind or have limited vision, and use a screen reader. Can I still take the exams?

We’re working on it. Our curriculum is fully screen reader accessible. We're still refining our screen reader usability for the Exam Environment app. This is a high priority for us.

I use a keyboard instead of a mouse. Can I navigate the exams using just a keyboard?

This is a high priority for us. We hope to add keyboard navigation to the Exam Environment app soon.

Are exams timed?

Yes, exams are timed. We err on the side of giving plenty of time to take the exam, to account for people who are non-native English speakers, or who have ADHD and other learning differences that can make timed exams more challenging.

If you have a condition that usually qualifies you for extra time on standardized exams, please email support@freecodecamp.org. We’ll review your request and see whether we can find a reasonable solution.

What happens if I fail the exam? Can I retake it?

Yes. You get one exam attempt per week. After you attempt an exam, there is a one-week (exactly 168 hour) “cool-down” period where you cannot take any freeCodeCamp exams. This is to encourage you to study and to pace yourself.

There is no limit to the number of times you can take an exam. So if you fail, study more, practice your skills more, then try again the following week.

Do I need to redo the projects if I fail the exam?

No. Once you’ve submitted a certification project, you do not need to ever submit it again.

You can re-do projects for practice, but we recommend that you instead build some of our many practice projects in freeCodeCamp’s developer interview job search section.

What happens if I already have the old Legacy Responsive Web Design certification? Should I claim the new one?

The new certification has more theory and practice as well as an exam. So if you’re looking to brush up on your skills, then you can go through the new version of this certification.

What will happen to my existing coursework progress on the Full Stack Certification? Does it transfer over to the Responsive Web Design course?

If you’ve already started the Certified Full Stack Developer Curriculum, all of your previously completed work should already be saved there.

To be clear, we’ve copied over all of the coursework from the full stack certification to this newer certification.

Can I still continue with the current Full Stack Developer Certification and just not do the new certification?

We’ve moved the coursework for the Full Stack Developer Certification over and broken it up into smaller certifications. Currently there are seven courses available for you to go through. Here is the complete list:

• Responsive Web Design Certification

• JavaScript Certification

• Frontend Libraries Certification

• Python Certification

• Relational Databases Certification

• Backend JavaScript Certification

• Certified Full Stack Developer Certification

The Certified Full Stack Developer Certification button will remain on the learn page for a short time to give people the opportunity to switch over to the new certifications. Over the next few months, though, this option will disappear.

Will my legacy certifications become invalid?

No. Once you claim a certification, it’s yours to keep.

Also note that we previously announced that freeCodeCamp certifications would have an expiration date and require recertification. We don’t plan to implement this anytime soon. And if we do decide to, we will give everyone at least a year’s notice.

Will the exam be available to take on my phone?

At this time, no. You’ll need to use a laptop or desktop to download the exam environment and take the exam. We hope to eventually offer these certification exams on iPhone and Android.

I have a disability or health condition that is not covered here. How can I request accommodations?

If you need specific accommodations for the exam (for example extra time, breaks, or alternative formats), please email support@freecodecamp.org. We’ll review your request and see whether we can find a reasonable solution.

Anything else?

Good luck working through freeCodeCamp’s coursework, building projects, and preparing for these exams.

Happy coding!

How Does the A2 English for Developers Certification Work?

In this English for Developers Certification, you'll learn the essentials of English communication. This will follow the A2 level of the Common European Framework of Reference (CEFR). And we've focused on vocabulary that is particularly useful for developers.

The first half of the curriculum will help you get comfortable with English grammar and usage. It will give you tons of hands-on practice. You'll learn basics like introducing yourself, making small talk, and discussing your work.

In the second half, you'll practice vocabulary specific to software development. You'll learn how to describe code, discuss tech trends, and participate in meetings.

Each section in this curriculum follows a unique theme, contains several dialogues, and is filled with hundreds of interactive tasks that will help you develop your English skills.

These tasks will introduce new vocabulary, teach grammar, or review concepts that you’ll need to know in order to understand what the characters from the dialogues are saying.

Each task will have an accompanying question that will help you practice the content.

The curriculum also has fill-in-the-blank questions that will help you practice writing in English.

This entire A2-level curriculum includes 105 different dialogues recorded by native English speakers. Each dialogue is designed to build your vocabulary and boost your confidence when speaking in a professional tech setting.

Once you’ve completed the certification, you’ll be able to take the A2 English for Developers exam. This exam contains 48 grammar questions, 36 listening questions, and 24 reading questions. All the questions are based on what’s covered in the certification course.

You can take the exam by using our new open source exam environment. The freeCodeCamp community designed this exam environment tool with two goals: respecting your privacy while also making it harder for people to cheat.

Once you download the app to your laptop or desktop, you can take the exam.

Frequently Asked Questions

Is all of this really free?

Yes. freeCodeCamp has always been free, and we’ve now offered free verified certifications for more than a decade. These exams are just the latest expansion to our community’s free learning resources.

Can I study the certification courses in languages other than English?

We aim to make every course available in all supported languages on freeCodeCamp. Check your account settings to see if the course you are studying is already offered in your preferred language.

What language skills does the curriculum cover?

The languages courses currently cover listening, reading, and writing. We have plans to add speaking later on.

Are the audio in the language courses and exams recorded by native language speakers?

Yes. All the audios present in the language courses were recorded by native speakers of that language.

I am Deaf or hard of hearing. Can I still study the language courses?

Yes! All audio lesson have closed captions and transcripts available for reading.

I am blind or have limited vision, and use a screen reader. Can I still study the language courses?

Yes! freeCodeCamp courses are designed to be accessible, and you can study the language courses using a screen reader. If you run into any accessibility issues, you can report them on our GitHub repository so the community can address them.

What are the letters and numbers beside the certification name? (For example: A1, A2, B1)

These labels refer to the CEFR levels, which is an international framework used to describe language proficiency. A1 and A2 represent beginner levels, B1 and B2 represent intermediate levels, and C1 and C2 represent advanced levels.

Each level indicates the skills and knowledge you are expected to have at that stage of your language learning journey.

What prevents people from just cheating on the exams?

Our goal is to strike a balance between preventing cheating and respecting people's right to privacy.

We've implemented a number of reliable, yet non-invasive, measures to help prevent people from cheating on freeCodeCamp's exams:

1. For each exam, we have a massive bank of questions and potential answers to those questions. Each time a person attempts an exam, they'll see only a small, randomized sampling of these questions.

2. We only allow people to attempt an exam one time per week. This reduces their ability to "brute force" the exam.

3. We have security in place to validate exam submissions and prevent man-in-the-middle attacks or manipulation of the exam environment.

4. We manually review each passing exam for evidence of cheating. Our exam environment produces tons of metrics for us to draw from.

We take cheating, and any form of academic dishonesty, seriously. We will act decisively.

This said, no one's exam results will be thrown out without human review, and no one's account will be banned without warning based on a single suspicious exam result.

Are these exams “open book” or “closed book”?

All of freeCodeCamp’s exams are “closed book”, meaning you must rely only on your mind and not outside resources.

Of course, in the real world you’ll be able to look things up. And in the real world, we encourage you to do so.

But that is not what these exams are evaluating. These exams are instead designed to test your memory of details and your comprehension of concepts.

So when taking these exams, do not use outside assistance in the form of books, notes, AI tools, or other people. Use of any of these will be considered academic dishonesty.

Do you record my webcam, microphone, or require me to upload a photo of my personal ID?

No. We considered adding these as additional test-taking security measures. But we have less privacy-invading methods of detecting most forms of academic dishonesty.

If the environment is open source, doesn't that make it less secure?

"Given enough eyeballs, all bugs are shallow." – Linus’s Law, formulated by Eric S. Raymond in his book The Cathedral and the Bazaar

Open source software projects are often more secure than their closed source equivalents. This is because a lot more people are scrutinizing the code. And a lot more people can potentially help identify bugs and other deficiencies, then fix them.

We feel confident that open source is the way to go for this exam environment system.

How can I contribute to the Exam Environment codebase?

It's fully open source, and we'd welcome your code contributions. Please read our general contributor onboarding documentation.

Then check out the GitHub repo.

You can help by creating issues to report bugs or request features.

You can also browse open help wanted issues and attempt to open pull requests addressing them.

Are the exam questions themselves open source?

For obvious exam security reasons, the exam question banks themselves are not publicly accessible. :)

These are built and maintained by freeCodeCamp's staff instructional designers.

What happens if I have internet connectivity issues mid-exam?

If you have internet connectivity issues mid exam, the next time you try to submit an answer, you’ll be told there are connectivity issues. The system will keep prompting you to retry submitting until the connection succeeds.

What if my computer crashes mid-exam?

If your computer crashes mid exam, you’ll be able to re-open the Exam Environment. Then, if you still have time left for your exam attempt, you’ll be able to continue from where you left off.

Can I take exams in languages other than English?

Not yet. We’re working to add multi-lingual support in the future.

I have completed my exam. Why can't I see my results yet?

All exam attempts are reviewed by freeCodeCamp staff before we release the results. We do this to ensure the integrity of the exam process and to prevent cheating. Once your attempt has been reviewed, you'll be notified of your results the next time you log in to freeCodeCamp.org.

I use a keyboard instead of a mouse. Can I navigate the exams using just a keyboard?

This is a high priority for us. We hope to add keyboard navigation to the Exam Environment app soon.

Are exams timed?

Yes, exams are timed. We err on the side of giving plenty of time to take the exam, to account for people who are non-native English speakers, or who have ADHD and other learning differences that can make timed exams more challenging.

If you have a condition that usually qualifies you for extra time on standardized exams, please email support@freecodecamp.org. We’ll review your request and see whether we can find a reasonable solution.

What happens if I fail the exam? Can I retake it?

Yes. You get one exam attempt per week. Afterward, if you don’t pass, there is a one-week (exactly 168 hour) “cool-down” period where you cannot take any freeCodeCamp exams. This is to encourage you to study and to pace yourself.

There is no limit to the number of times you can take an exam. So if you fail, study more, practice your skills more, then try again the following week.

Will the exam be available to take on my phone?

At this time, no. You’ll need to use a laptop or desktop to download the exam environment and take the exam. We hope to eventually offer these certification exams on iPhone and Android.

I have a disability or health condition that is not covered here. How can I request accommodations?

If you need specific accommodations for the exam (for example extra time, breaks, or alternative formats), please email support@freecodecamp.org. We’ll review your request and see whether we can find a reasonable solution.

Anything else?

Good luck working through freeCodeCamp’s languages coursework and preparing for the exam.

Happy learning!

Each certification is filled with hundreds of hours worth of interactive lessons, workshops, labs, and quizzes.

How Does the New JavaScript Certification Work?

The new JavaScript certification will teach you core concepts including variables, functions, loops, objects, higher order functions, DOM manipulation, working with events, asynchronous JavaScript, and more.

The certification is broken down into several modules that include lessons, workshops, labs, review pages, and quizzes to ensure that you truly understand the material before moving onto the next module.

The lessons are your first exposure to new concepts. They provide crucial theory and context for how things work in the software development industry.

These lessons include our new interactive editor so you can see previews of the code. You can also play around with the examples for deeper understanding and comprehension.

At the end of each lesson, there will be three comprehension check questions to test your understanding of the material from the lesson.

After the lesson blocks, you will do the workshops. These workshops are guided step-based projects that provide you with an opportunity to practice what you have learned in the lessons.

After the workshops, you will complete a lab which will help you review what you have learned so far. This will give you chance to start building projects on your own, which is a crucial skill for a developer. You will be presented with a list of users stories and will need to pass the tests to complete the lab.

At the end of each module, there is a review page containing a list of all of the concepts covered. You can use these review pages to help you study for the quizzes.

The last portion of the module is the quiz. This is a 20 question multiple choice quiz designed to test your understanding from the material covered in the module. You will need to get 18 out of 20 correct to pass.

Throughout the certification, there will be five certification projects you will need to complete in order to qualify for the exam.

Once you’ve completed all 5 certification projects, you’ll be able to take the 50 question exam using our new open source exam environment. The freeCodeCamp community designed this exam environment tool with two goals: respecting your privacy while also making it harder for people to cheat.

Once you download the app to your laptop or desktop, you can take the exam.

Frequently Asked Questions

Is all of this really free?

Yes. freeCodeCamp has always been free, and we’ve now offered free verified certifications for more than a decade. These exams are just the latest expansion to our community’s free learning resources.

What prevents people from just cheating on the exams?

Our goal is to strike a balance between preventing cheating and respecting people's right to privacy.

We've implemented a number of reliable, yet non-invasive, measures to help prevent people from cheating on freeCodeCamp's exams:

1. For each exam, we have a massive bank of questions and potential answers to those questions. Each time a person attempts an exam, they'll see only a small, randomized sampling of these questions.

2. We only allow people to attempt an exam one time per week. This reduces their ability to "brute force" the exam.

3. We have security in place to validate exam submissions and prevent man-in-the-middle attacks or manipulation of the exam environment.

4. We manually review each passing exam for evidence of cheating. Our exam environment produces tons of metrics for us to draw from.

We take cheating, and any form of academic dishonesty, seriously. We will act decisively.

This said, no one's exam results will be thrown out without human review, and no one's account will be banned without warning based on a single suspicious exam result.

Are these exams “open book” or “closed book”?

All of freeCodeCamp’s exams are “closed book”, meaning you must rely only on your mind and not outside resources.

Of course, in the real world you’ll be able to look things up. And in the real world, we encourage you to do so.

But that is not what these exams are evaluating. These exams are instead designed to test your memory of details and your comprehension of concepts.

So when taking these exams, do not use outside assistance in the form of books, notes, AI tools, or other people. Use of any of these will be considered academic dishonesty.

Do you record my webcam, microphone, or require me to upload a photo of my personal ID?

No. We considered adding these as additional test-taking security measures. But we have less privacy-invading methods of detecting most forms of academic dishonesty.

If the environment is open source, doesn't that make it less secure?

"Given enough eyeballs, all bugs are shallow." – Linus’s Law, formulated by Eric S. Raymond in his book The Cathedral and the Bazaar

Open source software projects are often more secure than their closed source equivalents. This is because a lot more people are scrutinizing the code. And a lot more people can potentially help identify bugs and other deficiencies, then fix them.

We feel confident that open source is the way to go for this exam environment system.

How can I contribute to the Exam Environment codebase?

It's fully open source, and we'd welcome your code contributions. Please read our general contributor onboarding documentation.

Then check out the GitHub repo.

You can help by creating issues to report bugs or request features.

You can also browse open help wanted issues and attempt to open pull requests addressing them.

Are the exam questions themselves open source?

For obvious exam security reasons, the exam question banks themselves are not publicly accessible. :)

These are built and maintained by freeCodeCamp's staff instructional designers.

What happens if I have internet connectivity issues mid-exam?

If you have internet connectivity issues mid exam, the next time you try submit an answer, you’ll be told there are connectivity issues. The system will keep prompting you to retry submitting until the connection succeeds.

What if my computer crashes mid-exam?

If your computer crashes mid exam, you’ll be able to re-open the Exam Environment. Then, if you still have time left for your exam attempt, you’ll be able to continue from where you left off.

Can I take exams in languages other than English?

Not yet. We’re working to add multi-lingual support in the future.

I have completed my exam. Why can't I see my results yet?

All exam attempts are reviewed by freeCodeCamp staff before we release the results. We do this to ensure the integrity of the exam process and to prevent cheating. Once your attempt has been reviewed, you'll be notified of your results the next time you log in to freeCodeCamp.org.

I am Deaf or hard of hearing. Can I still take the exams?

Yes! While some exams may include audio components, we do make written transcripts available for reading.

I am blind or have limited vision, and use a screen reader. Can I still take the exams?

We’re working on it. Our curriculum is fully screen reader accessible. We're still refining our screen reader usability for the Exam Environment app. This is a high priority for us.

I use a keyboard instead of a mouse. Can I navigate the exams using just a keyboard?

This is a high priority for us. We hope to add keyboard navigation to the Exam Environment app soon.

Are exams timed?

Yes, exams are timed. We err on the side of giving plenty of time to take the exam, to account for people who are non-native English speakers, or who have ADHD and other learning differences that can make timed exams more challenging.

If you have a condition that usually qualifies you for extra time on standardized exams, please email support@freecodecamp.org. We’ll review your request and see whether we can find a reasonable solution.

What happens if I fail the exam? Can I retake it?

Yes. You get one exam attempt per week. After you attempt an exam, there is a one-week (exactly 168 hour) “cool-down” period where you cannot take any freeCodeCamp exams. This is to encourage you to study and to pace yourself.

There is no limit to the number of times you can take an exam. So if you fail, study more, practice your skills more, then try again the following week.

Do I need to redo the projects if I fail the exam?

No. Once you’ve submitted a certification project, you do not need to ever submit it again.

You can re-do projects for practice, but we recommend that you instead build some of our many practice projects in freeCodeCamp’s developer interview job search section.

What happens if I already have the old Legacy Responsive Web Design certification? Should I claim the new one?

The new certification has more theory and practice as well as an exam. So if you’re looking to brush up on your skills, then you can go through the new version of this certification.

What will happen to my existing coursework progress on the Full Stack Certification? Does it transfer over to the Responsive Web Design course?

If you’ve already started the Certified Full Stack Developer Curriculum, all of your previously completed work should already be saved there.

To be clear, we’ve copied over all of the coursework from the full stack certification to this newer certification.

Can I still continue with the current Full Stack Developer Certification and just not do the new certification?

We’ve moved the coursework for the Full Stack Developer Certification over and broken it up into smaller certifications. Currently there are seven courses available for you to go through. Here is the complete list:

• Responsive Web Design Certification

• JavaScript Certification

• Frontend Libraries Certification

• Python Certification

• Relational Databases Certification

• Backend JavaScript Certification

• Certified Full Stack Developer Certification

The Certified Full Stack Developer Certification button will remain on the learn page for a short time to give people the opportunity to switch over to the new certifications. Over the next few months, though, this option will disappear.

Will my legacy certifications become invalid?

No. Once you claim a certification, it’s yours to keep.

Also note that we previously announced that freeCodeCamp certifications would have an expiration date and require recertification. We don’t plan to implement this anytime soon. And if we do decide to, we will give everyone at least a year’s notice.

Will the exam be available to take on my phone?

At this time, no. You’ll need to use a laptop or desktop to download the exam environment and take the exam. We hope to eventually offer these certification exams on iPhone and Android.

I have a disability or health condition that is not covered here. How can I request accommodations?

If you need specific accommodations for the exam (for example extra time, breaks, or alternative formats), please email support@freecodecamp.org. We’ll review your request and see whether we can find a reasonable solution.

Anything else?

Good luck working through freeCodeCamp’s coursework, building projects, and preparing for these exams.

Happy coding!

Each certification is filled with hundreds of hours worth of interactive lessons, workshops, labs, and quizzes.

How Does the New RWD Certification Work?

The Responsive Web Design certification will teach you core concepts including semantic HTML, working with forms, the importance of accessibility, CSS Flexbox, responsive design, CSS Grid, and more.

The certification is broken down into several modules that include lessons, workshops, labs, review pages and quizzes to ensure that you truly understand the material before moving onto the next module.

The lessons are your first exposure to new concepts. They provide crucial theory and context for how things work in the software development industry.

These lessons include our new interactive editor so you can see previews of the code. You can also play around with the examples for deeper understanding and comprehension.

At the end of each lesson, there will be three comprehension check questions to test your understanding of the material from the lesson.

After these lessons, you’ll head over to the workshops. These workshops are guided step-based projects that provide you with an opportunity to practice what you have learned in the lessons.

After the workshops, you’ll complete a lab which will help you review what you have learned so far. This will give you the chance to start building projects on your own, which is a crucial skill for a developer. You’ll be presented with a list of user stories and will need to pass the tests to complete the lab.

At the end of each module, there is a review page containing a list of all of the concepts covered. You can use these review pages to help you study for the quizzes.

The last portion of the module is the quiz. This is a 20 question multiple choice quiz designed to test your understanding from the material covered in the module. You’ll need to get 18 out of 20 correct to pass.

Throughout the certification, there will be five certification projects you’ll need to complete in order to qualify for the exam.

Once you’ve completed all 5 certification projects, you’ll be able to take the 50 question exam using our new open source exam environment. The freeCodeCamp community designed this exam environment tool with two goals: respecting your privacy while also making it harder for people to cheat.

Once you download the app to your laptop or desktop, you can take the exam.

Frequently Asked Questions

Is all of this really free?

Yes. freeCodeCamp has always been free, and we’ve now offered free verified certifications for more than a decade. These exams are just the latest expansion to our community’s free learning resources.

What prevents people from just cheating on the exams?

Our goal is to strike a balance between preventing cheating and respecting people's right to privacy.

We've implemented a number of reliable, yet non-invasive, measures to help prevent people from cheating on freeCodeCamp's exams:

1. For each exam, we have a massive bank of questions and potential answers to those questions. Each time a person attempts an exam, they'll see only a small, randomized sampling of these questions.

2. We only allow people to attempt an exam one time per week. This reduces their ability to "brute force" the exam.

3. We have security in place to validate exam submissions and prevent man-in-the-middle attacks or manipulation of the exam environment.

4. We manually review each passing exam for evidence of cheating. Our exam environment produces tons of metrics for us to draw from.

We take cheating, and any form of academic dishonesty, seriously. We will act decisively.

This said, no one's exam results will be thrown out without human review, and no one's account will be banned without warning based on a single suspicious exam result.

Are these exams “open book” or “closed book”?

All of freeCodeCamp’s exams are “closed book”, meaning you must rely only on your mind and not outside resources.

Of course, in the real world you’ll be able to look things up. And in the real world, we encourage you to do so.

But that is not what these exams are evaluating. These exams are instead designed to test your memory of details and your comprehension of concepts.

So when taking these exams, do not use outside assistance in the form of books, notes, AI tools, or other people. Use of any of these will be considered academic dishonesty.

Do you record my webcam, microphone, or require me to upload a photo of my personal ID?

No. We considered adding these as additional test-taking security measures. But we have less privacy-invading methods of detecting most forms of academic dishonesty.

If the environment is open source, doesn't that make it less secure?

"Given enough eyeballs, all bugs are shallow." – Linus’s Law, formulated by Eric S. Raymond in his book The Cathedral and the Bazaar

Open source software projects are often more secure than their closed source equivalents. This is because a lot more people are scrutinizing the code. And a lot more people can potentially help identify bugs and other deficiencies, then fix them.

We feel confident that open source is the way to go for this exam environment system.

How can I contribute to the Exam Environment codebase?

It's fully open source, and we'd welcome your code contributions. Please read our general contributor onboarding documentation.

Then check out the GitHub repo.

You can help by creating issues to report bugs or request features.

You can also browse open help wanted issues and attempt to open pull requests addressing them.

Are the exam questions themselves open source?

For obvious exam security reasons, the exam question banks themselves are not publicly accessible. :)

These are built and maintained by freeCodeCamp's staff instructional designers.

What happens if I have internet connectivity issues mid-exam?

If you have internet connectivity issues mid exam, the next time you try submit an answer, you’ll be told there are connectivity issues. The system will keep prompting you to retry submitting until the connection succeeds.

What if my computer crashes mid-exam?

If your computer crashes mid exam, you’ll be able to re-open the Exam Environment. Then, if you still have time left for your exam attempt, you’ll be able to continue from where you left off.

Can I take exams in languages other than English?

Not yet. We’re working to add multi-lingual support in the future.

I have completed my exam. Why can't I see my results yet?

All exam attempts are reviewed by freeCodeCamp staff before we release the results. We do this to ensure the integrity of the exam process and to prevent cheating. Once your attempt has been reviewed, you'll be notified of your results the next time you log in to freeCodeCamp.org.

I am Deaf or hard of hearing. Can I still take the exams?

Yes! While some exams may include audio components, we do make written transcripts available for reading.

I am blind or have limited vision, and use a screen reader. Can I still take the exams?

We’re working on it. Our curriculum is fully screen reader accessible. We're still refining our screen reader usability for the Exam Environment app. This is a high priority for us.

I use a keyboard instead of a mouse. Can I navigate the exams using just a keyboard?

This is a high priority for us. We hope to add keyboard navigation to the Exam Environment app soon.

Are exams timed?

Yes, exams are timed. We err on the side of giving plenty of time to take the exam, to account for people who are non-native English speakers, or who have ADHD and other learning differences that can make timed exams more challenging.

If you have a condition that usually qualifies you for extra time on standardized exams, please email support@freecodecamp.org. We’ll review your request and see whether we can find a reasonable solution.

What happens if I fail the exam? Can I retake it?

Yes. You get one exam attempt per week. After you attempt an exam, there is a one-week (exactly 168 hour) “cool-down” period where you cannot take any freeCodeCamp exams. This is to encourage you to study and to pace yourself.

There is no limit to the number of times you can take an exam. So if you fail, study more, practice your skills more, then try again the following week.

Do I need to redo the projects if I fail the exam?

No. Once you’ve submitted a certification project, you do not need to ever submit it again.

You can re-do projects for practice, but we recommend that you instead build some of our many practice projects in freeCodeCamp’s developer interview job search section.

What happens if I already have the old Legacy Responsive Web Design certification? Should I claim the new one?

The new certification has more theory and practice as well as an exam. So if you’re looking to brush up on your skills, then you can go through the new version of this certification.

What will happen to my existing coursework progress on the Full Stack Certification? Does it transfer over to the Responsive Web Design course?

If you’ve already started the Certified Full Stack Developer Curriculum, all of your previously completed work should already be saved there.

To be clear, we’ve copied over all of the coursework from the full stack certification to this newer certification.

Can I still continue with the current Full Stack Developer Certification and just not do the new certification?

We’ve moved the coursework for the Full Stack Developer Certification over and broken it up into smaller certifications. Currently there are seven courses available for you to go through. Here is the complete list:

• Responsive Web Design Certification

• JavaScript Certification

• Frontend Libraries Certification

• Python Certification

• Relational Databases Certification

• Backend JavaScript Certification

• Certified Full Stack Developer Certification

The Certified Full Stack Developer Certification button will remain on the learn page for a short time to give people the opportunity to switch over to the new certifications. Over the next few months, though, this option will disappear.

Will my legacy certifications become invalid?

No. Once you claim a certification, it’s yours to keep.

Also note that we previously announced that freeCodeCamp certifications would have an expiration date and require recertification. We don’t plan to implement this anytime soon. And if we do decide to, we will give everyone at least a year’s notice.

Will the exam be available to take on my phone?

At this time, no. You’ll need to use a laptop or desktop to download the exam environment and take the exam. We hope to eventually offer these certification exams on iPhone and Android.

I have a disability or health condition that is not covered here. How can I request accommodations?

If you need specific accommodations for the exam (for example extra time, breaks, or alternative formats), please email support@freecodecamp.org. We’ll review your request and see whether we can find a reasonable solution.

Anything else?

Good luck working through freeCodeCamp’s coursework, building projects, and preparing for these exams.

Happy coding!

Consistent practice is one of the most effective ways to improve your coding skills. So in addition to the core coding curriculum, you can now keep your programming skills sharp by solving a fun new coding challenge every single day.

Each day at midnight US Central time, a new programming puzzle will unlock on freecodecamp.org and the freeCodeCamp mobile app that you can solve in JavaScript and Python.

How to Start Solving Daily Coding Challenges

On the freeCodeCamp Mobile App:

1. Download the freeCodeCamp mobile app from the Google Play Store or the Apple App Store and open it.

2. Don’t forget to sign in if you want to save your progress. Then find todays challenge at the top and click “Start the challenge”:

3. Choose your preferred language:

4. Read the challenge instructions:

5. Write the code:

6. Pass the tests:

And voilà! You’ve completed the challenge.

On the Website:

1. Go to freecodecamp.org and make sure you’re logged in if you want to save your progress. Then scroll down to find the coding challenge of the day and click “Start”:

2. Choose your preferred language at the top

3. Read the challenge instructions, write the code, and pass the tests:

What if I Missed a Day?

Don’t worry if you miss a challenge. Both the mobile app and website include an archive page, where you can browse and complete past challenges at your own pace:

Start Your first Challenge Today

Today’s challenge is waiting for you. Open the freeCodeCamp app or head to freecodecamp.org to complete it. 🚀

It’s only been a few months, but already there are many campers going full-force through these new lessons and programming challenges.

I’m excited to share our next wave of updates with you all.

New Curriculum Coursework

We have just released three new sections of the curriculum: The React Hooks and State section, the Performance section, and the Testing section.

This new coursework includes:

• 50 lecture videos

• a dozen workshops and labs

• three new review blocks

• and a bunch of coursework to keep you on track with your learning goals (while we work to finish the remainder of the Full Stack curriculum.)

Some of the projects you’ll build include:

• a fully playable Tic Tac Toe game

• a color picker

• and a superhero application form

Exams

We know many of you are eagerly awaiting the release of the exams at the end of each module. These are nearly ready.

We’re also building our own custom exam environment that you can use to take these exams. This will strike a balance between respecting privacy and preserving academic integrity.

What’s Next?

The community is now focused on the CSS Libraries and TypeScript modules next. We’re also building Python modules.

We have a lot of stuff coming out in the next few months.

A super early sneak peek of some of the projects coming soon:

• build your own RPG character

• a trading card game

• a medical data validator

• and more 🏕️

Get Involved

Are you interested in helping bring our full stack curriculum to life? We have plenty of opportunities to contribute – you can see all of the open issues on our GitHub repository.

Start by reading our contributor onboarding guide. Then hop on over to our Discord community with any questions you may have.

We’re stoked to watch you plow through all this new coursework. Keep up the forward momentum with your skills. Happy Coding! 💜

Did you know that organizations such as freeCodeCamp, Google, and Harvard offer online courses to help you learn software development? And that many of these include free certificates and badges?

To help you choose one that's right for you, I've created a full list.

As avid online learners, my Class Central colleagues and I have completed hundreds of online courses over the years, including many with free certificates, as you can see in the collage below.

In 2025, free certificates have become rarer. But if you know where to look, there is still an abundance of free certificates available online for learning software development.

Some of the free certificates earned by the Class Central team.

As you likely know, freeCodeCamp offers free certifications. But so do big tech companies and institutions such as Google, Microsoft, and Harvard.

In this article, we bring together all the free certificates and badges that are scattered across the web. In total, the platforms below offer over 900 free certificate courses for learning software development.

I (Dhawal) started Class Central back in 2011, when universities such as Stanford began to offer some of their courses online for free. Since then, the Class Central database has grown to over 250K online courses.

Having written about online education for over a decade, I remember when platforms like Coursera and edX offered free certificates. Then, rather abruptly, free certificates seemed to pretty much disappear.

This inspired us to write a Massive List of Free Certificates and Badges. To our surprise, we discovered there were still thousands of free certificates available online. To date, that article has received 10M views.

In the same vein, this article aims to draw attention to the organizations that continue to support open education in software development by offering free certificate courses. These include:

• Learning platforms — e.g. LinkedIn Learning, CodeSignal, and freeCodeCamp

• Leading universities — e.g. Harvard and the University of Helsinki

• Big tech companies — e.g. Google and IBM.

Please note, Class Central is not involved in running the courses or issuing certificates. This is a dynamic field and you may discover that a course you choose is no longer available, or doesn’t have a free certificate any more. We recommend you always check before starting a course.

freeCodeCamp Free Certifications

Archisha's freeCodeCamp free certificate

freeCodeCamp platform offers thousands of hours of learning content, broken down into certifications on subjects such as web development and data science.

Here are the certifications currently offered, several others are due to be released soon:

• Responsive Web Design Certification

• Front End Development Libraries Certification

• Back End Development and APIs

• Back End Development and APIs (in development) ★★★★★(3)

• Certified Full Stack Developer (in development)

• Relational Database

• JavaScript Certification

• Foundational C# with Microsoft

• Certified Full Stack Developer

• Python

While strictly not developer courses, A2 English for Developers and  B1 English for Developers focuses on vocabulary that is particularly useful for developers. Prepare for real-world interactions by applying English skills in professional and technical settings.

Cisco Free Badges

Cisco Network Academy

Cisco, the IT and networking giant, offers a series of self-paced online courses through its Networking Academy platform; some include free badges for skills learned. Here’s a selection:

• Introduction to Cybersecurity

• NDG Linux Unhatched

• NDG Linux Essentials

• CPA: Programming Essentials in C++

• Introduction to IoT

• Python Essentials 1

You can find the full list of Cisco Networking Academy courses here.

CodeSignal Free Certificates

Pat's free CodeSignal certificate

CodeSignal is a growing platform that offers 2000+ courses and learning paths with free certificates in coding, AI & ML, data science, interview prep, and more. As well as developer and IT certificates, CodeSignal teaches valuable soft skills.

Here’s a selection:

• Introduction to Programming with Python

• Four-Week Coding Interview Prep in Python

• Prompt Engineering for Everyone

• Comprehensive Introduction to Front-End Engineering

• JavaScript Programming for Beginners

• Java Programming for Beginners

• Implementing AI Algorithms from Scratch

• Introduction to Machine Learning with SciKit Learn

• Supercommunicators – Have Conversations that Matter

• Dare to Lead – Unlock Courageous Leadership

You can find more details in our dedicated article, and the full list of CodeSignal Learn courses.

Google Free Certificates and Badges

Pat’s free Google badge

Google has launched several initiatives to teach people skills such as coding, digital marketing, and data analytics. Some offer certificates, some have badges.

Here is a selection of Google’s offerings:

• Introduction to Generative AI

• Introduction to Responsible AI

• Introduction to Image Generation

• Planetary Scale Earth Observation with Google Earth Engine

• Introduction to Large Language Models

• Google Analytics Certification

• Build your first web app with Firebase

• Build apps with Flutter

• Introduction to SQL

• Get data from the internet

• Adapt for different screen sizes

• Kotlin fundamentals

• Develop locally with Firebase

• Make your Android app more accessible

• Build cross-platform apps with Angular

• Jetpack Compose basics

• Site Reliability Engineering: Measuring and Managing Reliability

• Attention Mechanism

• Transformer Models and BERT Model

• Create Image Captioning Models

• Encoder-Decoder Architecture

• Hybrid Cloud Infrastructure Foundations with Anthos

• Preparing for the Google Cloud Professional Data Engineer Exam

• Understanding Google Cloud Security and Operations

• Innovating with Data and Google Cloud

• Infrastructure and Application Modernization with Google Cloud

• Developing a Google SRE Culture

• Managing Change when Moving to Google Cloud

• Deploying SAP on Google Cloud

• The Modern Data Platform and LookML

• Digital Transformation with Google Cloud

• Managing and Securing the Apigee Hybrid API Platform

• Upgrading and Monitoring the Apigee Hybrid API Platform

• Preparing for Your Professional Cloud Security Engineer Journey

• Preparing for Your Associate Cloud Engineer Journey

• Preparing for your Professional Cloud Architect Journey

• Innovating with Data and Google Cloud

• Preparing for Your Professional Cloud Network Engineer Journey

• Design Foundations for Streaming with Google Cloud

• Introduction to Cloud Identity

You can find more details in our dedicated article and here is a complete list of courses by Google.

HackerRank Free Certificates

Manoel’s HackerRank free certificate

HackerRank is a platform for learning algorithms and data structures and preparing for coding interviews, provides skills certifications tests in topics such as problem solving, Python, and JavaScript.

Here are some of the 24 tests you may complete to earn a certificate:

• Problem Solving (Basic) Skills Certification

• Python (Basic) Skills Certification

• Java (Basic) Skills Certification

• C# (Basic) Skills Certification

• JavaScript (Basic) Skills Certification

• SQL (Basic) Skills Certification

• Go (Basic) Skills Certification

• R (Basic) Skills Certification

• Node (Basic) Skills Certification

Harvard Free Certificates

Pat’s Free Harvard CS50 Scratch Certificate

Harvard offers a series of academic online courses exploring various facets of computer science, including programming fundamentals and AI.

Here are Harvard’s current free certificate offerings. Remember that while you need an account with edX to submit the assignments, the free certificate comes directly from CS50.

• Introduction to Computer Science

• Computer Science for Business Professionals

• Introduction to Artificial Intelligence with Python

• Web Programming with Python and JavaScript

• Computer Science for Lawyers

• Introduction to Programming with Python

• Introduction to Programming with Scratch

• Introduction to Cybersecurity

• Introduction to Databases with SQL

• Introduction to Programming with R

You can find more details and how to receive your free certificate in our dedicated article and here is a complete list of courses from Harvard.

Hasso Plattner Institute Free Certificates

Hasso Plattner Institute free courses

The Hasso Plattner Institute offers a range of self-paced courses with free certificates of participation and achievement. Most courses are in German, but some are in English.

Here’s a selection of courses in English:

• Understanding Embeddings for Natural Language Processing

• Data Science Bootcamp

• Introduction to Bayesian Data Analysis

• Introduction to Quantum Computing with Qiskit (with IBM Quantum)

Hugging Face Free Certificates

Hugging Face courses

Hugging Face develops computation tools for building applications using machine learning and offers several courses, some with free certificates.

• Model Context Protocol (MCP)

• AI Agents

• Deep Reinforcement Learning

• Audio

IBM Free Certificates and Badges

The CognitiveClass.ai homepage

IBM’s platform CognitiveClass.ai offers 100+ courses and 10 learning paths in data science, AI, big data, cloud computing, and blockchain. Some courses offer a completion badge or certificate. Check on the Cognitive Class.AI course page for details.

The platform also provides a virtual lab environment allowing users to practice what they’ve learned in the courses.

Here’s a selection:

• Accelerating Deep Learning with GPUs

• Introduction to Open Source

• Text Analytics 101

• Applied Data Science with R

• Big Data Foundations

Pat’s free certificate and badge for Introduction to IBM Storage and Cloud

Some of the 24 free learning paths and 582 free courses from IBM Training have free certificates and badges available from IBM Training or via Credly. Courses are in a range of fields including AI, automation, infrastructure, cloud, security, and more.

Kaggle Free Certificates

Kaggle free certificate courses

Kaggle is an online community for data scientists and aspiring data scientists alike. It offers over 50K public datasets, allowing you to build your own data science projects through Jupyter notebooks, and participate in competitions.

In addition, the platform offers a series of courses to learn the fundamentals of data science. Each leads to a certificate of completion.

• Python

• Intro to SQL

• Advanced SQL

• Intro to Deep Learning

• Data Cleaning

• Time Series

• Computer Vision

• Intro to Machine Learning

• Pandas

• Data Visualization

• Intro to AI Ethics

• Machine Learning Explainability

• Feature Engineering

• Intermediate Machine Learning

• Intro to Game AI and Reinforcement Learning

LinkedIn Learning Courses with Free Certificates

Suparn’s LinkedIn Learning free certificate

LinkedIn Learning, the online learning platform integrated with the LinkedIn professional social network, offers more than a hundred online courses and learning paths that include a free certificate.

Here’s a selection of LinkedIn Learning free certificate courses:

• Programming Foundations: Fundamentals

• Programming Foundations: Beyond the Fundamentals

• Learning Data Analytics: 1 Foundations

• Learning Data Science: Understanding the Basics

• The Cybersecurity Threat Landscape

You can find more details and the full list or free certificates in our dedicated article, and here is a complete list of courses by LinkedIn Learning.

MATLAB Free Certificates

MATLAB free courses

MathWorks, the company behind the MATLAB programming language and software, offers 23 free online courses with certificates through their MATLAB Academy platform.

The courses introduce learners to the MATLAB language and tools — with a focus on machine learning — and MathWorks’ specialized software, such as Simulink. You can find all the details and how to receive your free certificate in our dedicated article.

Here’s a selection:

• MATLAB Onramp

• Machine Learning Onramp

• Reinforcement Learning Onramp

• Signal Processing Onramp

• Stateflow Onramp

• Circuit Simulation Onramp

• Deep Learning Onramp

• Wireless Communications Onramp

• Simscape Onramp

• Optimization Onramp

• App Building Onramp

• Object-Oriented Programming Onramp

• Computer Vision Onramp

• Simulink Onramp

• Control Design Onramp with Simulink

• System Composer Onramp

• Power Systems Simulation Onramp

Semrush Academy Free Certificates

Semrush Academy free courses

Although Semrush is primarily a business and marketing specialist, some of their free certificate courses are relevant for developers and IT professionals:

• On-Page and Technical SEO Course

• Mobile SEO Course with Greg Gifford

• Technical SEO course with Bastian Grimm

• Semrush SEO Crash Course with Brian Dean

University of Helsinki Free Certificates

Pat’s Elements of AI free certificate

The University of Helsinki offers academic online courses through its independent course platform, MOOC.fi, including the following courses which include a free certificate of completion:

• Elements of AI

• Full Stack open

• Java Programming

• Cyber Security Base

• Ethics of AI

upGrad Free Certificates

Suparn’s upGrad free certificate

upGrad is an online learning platform that offers free programs and courses on subjects such as data science, business analytics, and technology.

An e-Certificate of Completion is provided in 30 days after you successfully finish all the modules within your program. Your phone number is required while registering a course so you may receive calls and messages from upGrad.

Here are some of the free programs offered on upGrad:

• Programming with Python: Introduction for Beginners

• Introduction to Natural Language Processing

• Introduction to Data Analysis using Excel

• Introduction to Database Design with MySQL

• Data Science in E-commerce

• Introduction to NFTs

• E-Skills in Healthcare

• Core Java Basics

• Introduction to Blockchain Technology

FutureLearn Free Certificates

Elham’s FutureLearn free certificate

FutureLearn, the European counterpart to Coursera and edX, offers some courses that include a free “digital upgrade” — which, among others, entails a free certificate of completion.

Here’s a list of some of FutureLearn’s free offerings:

• Digital Skills: Digital Skills for Work and Life

• Digital Skills: Digital Marketing

• Digital Skills: Social Media

• Digital Skills: Artificial Intelligence

• Digital Skills: User Experience

• Introduction to Virtual, Augmented and Mixed Reality

• Digital Skills: Reimagine Your Career

• Digital Skills: Mobile

• Digital Skills: Web Analytics

You can find more details in our dedicated article and here is a full list of FutureLearn courses.

Wolfram U Free Certificates

Wolfram U free courses

The Wolfram Language is a powerful programming tool employed in science, engineering, data science, and finance. It combines math, data analysis, and general programming, and forms the core of Wolfram’s popular software, Mathematica. You can find all the details in our dedicated article.

Here is a selection of Wolfram U’s 40+ free certificate courses:

• Full Interactive Course for Introduction to Wolfram Language

• Quick Start to Wolfram Tech Course

• Wolfram Language Programming Proficiency

• Programming Fundamentals of Wolfram Language

• A Guide to Programming Course

• Practical Programming with Wolfram Language

• Wolfram Language Fast Introduction for Programmers Video Series

• Programming and Development in Wolfram Language Instructor Led Course

• Getting Started with Mathematica and Wolfram Language: Wolfram Daily Study Groups

• Wolfram Summer School Lectures: Online Course

• Visual Explorations in Data Science Course

• Multiparadigm Data Science, Interactive Online Video Course

• Introduction to Machine Learning

• Introduction to Neural Networks in Wolfram Language Class

• Data Visualization with Wolfram Language

• Wolfram Language and LLMs Instructor-Led Course

• Computational Xplorations

• Creative Computation, Online Video Course

• Introduction to Notebooks, Interactive Online Video Course

• Notebooks as Instructional Tools—Wolfram U Instructor-Led Course

• Wolfram Notebooks: Building and Sharing Technical Workflows

• Introduction to Image Processing, Interactive Online Video Course

• Signals, Systems and Signal Processing Course

More Free Certificates

If you don’t find what you need here, browse Class Central’s catalog of 250K courses or visit our thematic collections:

• Massive List of Thousands of Free Certificates and Badges

• Stanford Medicine Offers Courses with Free Certificate & CME Credit

• 470+ Hours of Free LinkedIn Learning Courses with Free Certification

• 300+ Free Digital Marketing Certificates

• 900+ Open University Free Certificates

• 600+ Courses from Top Med Schools with Free Certificate & CME Credit

You can find all our free certificates articles here.