Viral Genome GC Content Analyzer

Parse real SARS-CoV-2 genomes and compare GC content using Biopython.

Introduction

30 Second Summary

When scientists want to quickly compare two viruses, they often start with a single number. That number, called GC content, reveals the chemical balance of a genome and can hint at how a virus behaves, adapts, and evolves.

In this project, you will build a Python pipeline that parses real SARS-CoV-2 genome sequences from a public database. You will calculate GC content for five different viral strains and export a professional comparison report.

What You'll Build

Picture running one script and watching a sorted comparison of five real SARS-CoV-2 strains appear in your terminal, with a shareable report saved alongside it.

By the end of this project, you'll have:

  • A genome parser powered by Biopython that loads any FASTA file and instantly displays its sequence ID, length, and base composition.
  • A sorted Pandas DataFrame comparing GC content across five real SARS-CoV-2 isolates from different countries, complete with summary statistics.
  • An exported CSV report of your genomic analysis, plus a Git history capturing every milestone of how the analysis evolved.
  • An optional Secret Mission to push your analysis skills further.

Are there any prerequisites?

No prior bioinformatics experience is needed. You just need Python, VS Code, and Git on your machine, and this project handles the rest.

Before We Start

Before we dive in, let's lock in what you're about to build and why it matters.

Set Up Your Bioinformatics Workspace

Genome analysis involves raw data files, specialized libraries, and scripts that evolve as you explore the data. Without a structured workspace, things get messy fast.

In this step, you'll create a project folder with Git tracking, install the Python libraries for parsing genomes and organizing results, and lock in your first commit.

In this step, get ready to:
  • Create a project folder, initialize a Git repository, and set up your project files.
  • Install Biopython and Pandas via pip.
  • Make your first Git commit to capture the project scaffold.
Create your project folder and initialize Git

Your project needs a dedicated folder on your Desktop and a Git repository to track every change you make. You'll also create the files and folders the project will use.

  • Press Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
  • Type Terminal and press Enter to open it.

Windows users

This project uses bash commands throughout. If you're on Windows, open Git Bash instead of PowerShell or Command Prompt. Since you have Git installed, Git Bash is already available on your machine.

  • Move to your Desktop by running this command:
cd ~/Desktop
  • Create your project folder and move into it by running these commands:
mkdir gc-analyzer
cd gc-analyzer
  • Initialize a Git repository in this folder by running:
git init

You should see a message like Initialized empty Git repository in... confirming Git is tracking this folder.

  • Create your Python script file and a folder for genome data by running these commands:
touch analyze.py
mkdir genomes
  • Confirm the files exist by running:
ls

You should see analyze.py and genomes listed in the output.

Don't see both items?

Make sure you ran both touch analyze.py and mkdir genomes from inside the gc-analyzer folder. Run pwd to check your current directory.

help me create analyze.py and a genomes folder inside my gc-analyzer project

Now open your project in VS Code so you can work with your files and terminal in one place.

  • Press Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
  • Type VS Code and press Enter to open it.
  • In VS Code, click File in the top menu bar.
  • Click Open Folder.
  • Select the gc-analyzer folder on your Desktop, then click Open.

You should see analyze.py and the genomes folder listed in the Explorer sidebar on the left.

Install Biopython and Pandas

Your project depends on two Python libraries. Biopython provides tools for parsing biological data formats like FASTA files. Pandas organizes data into structured tables you can sort, filter, and export.

  • Open the integrated terminal in VS Code by pressing Ctrl+` (backtick key, next to the number 1) on both macOS and Windows.
  • Install both libraries by running:
pip install biopython pandas

You should see pip download and install both packages. When it finishes, you'll see Successfully installed followed by the package names and version numbers.

Seeing command not found?

If pip is not recognized, try pip3 instead. Some systems install Python's package manager as pip3.

If you see a permissions error, add the --user flag to install for your user account only.

help me install biopython and pandas with pip

Before you run the next command, what do you think will happen if the installations worked correctly?

  • Verify the libraries are importable by running:
python -c "from Bio import SeqIO; from Bio.SeqUtils import gc_fraction; import pandas; print('All good!')"

You should see All good! printed in the terminal with no errors.

What does this command do?

The -c flag tells Python to run a short snippet directly from the terminal instead of from a file. This snippet imports the three key modules you'll use throughout the project and prints a confirmation message if all imports succeed.

Seeing ModuleNotFoundError?

If python is not recognized, try replacing python with python3 in the command. Some systems use python3 as the default command.

If you see a ModuleNotFoundError, your pip and python commands might point to different Python installations. Try python3 -m pip install biopython pandas to ensure the libraries install for the correct Python version.

help me fix a ModuleNotFoundError when importing Biopython or Pandas

Make your first Git commit

Git captures snapshots of your project at key moments. Your first commit records the empty scaffold before any analysis code goes in.

  • Stage all project files and create your first commit by running these commands:
git add .
git commit -m "Initial project scaffold"

What do these commands do?

  • git add . stages every file in the current folder, telling Git to include them in the next snapshot.
  • git commit -m "..." saves that snapshot with a descriptive message so you can find it later.

You should see output confirming the commit, including the number of files changed and the branch name.

Seeing 'Please tell me who you are'?

Git needs your name and email to label commits. Run these two commands with your own details, then retry the commit:

git config --global user.name "Your Name"
git config --global user.email "your@email.com"

help me configure Git so I can make my first commit

Your workspace is ready. You have a Git-tracked project with the right libraries installed. Next up, you'll download a real SARS-CoV-2 genome and parse it with Biopython.

Parse Your First Viral Genome

Your workspace is ready. Now you need actual genome data to work with.

In this step, you will download a real SARS-CoV-2 genome from the NCBI database and write a Python script that reads it using Biopython. By the end, your script will print the genome's key details to prove it can parse real biological data.

In this step, get ready to:
  • Download a SARS-CoV-2 reference genome from NCBI.
  • Write a Python script that parses the genome file and prints its key details.
  • Commit the working parser to Git.
Download the SARS-CoV-2 reference genome

Genome sequences are stored in a text format called FASTA. A FASTA file starts with a header line (beginning with >) followed by the raw nucleotide sequence. NCBI hosts millions of these files in its public database.

You will download the Wuhan-Hu-1 reference genome, which is the original SARS-CoV-2 sequence that researchers worldwide use as a baseline for comparison.

  • Open this link in your browser to go to the NCBI record for accession NC_045512.2:
https://www.ncbi.nlm.nih.gov/nuccore/NC_045512.2
  • On the record page, click Send to: in the upper right area above the record.
  • Select Complete Record.
  • Under Choose Destination, select File.
  • In the Format dropdown, select FASTA.
  • Click Create File. Your browser will download a file called sequence.fasta.

What is an accession number?

Every sequence in the NCBI database has a unique accession number. NC_045512.2 identifies the second version of the SARS-CoV-2 Wuhan-Hu-1 reference genome. Think of it like a library call number for a specific book.

The downloaded file needs to be renamed and moved into your project's genomes/ folder.

  • Find sequence.fasta in your Downloads folder.
  • Rename the file to NC_045512.2.fasta.
  • Move the renamed file into the genomes/ folder inside your project.
  • Confirm the file is in place by running this command in your terminal:
ls genomes/

You should see NC_045512.2.fasta listed in the output.

Don't see the file?

Make sure you moved the file into the genomes/ folder inside your project directory, not the project root. Also check that you renamed it to NC_045512.2.fasta (not sequence.fasta).

Make sure your terminal is in the project folder. Run pwd to check your current directory.

Still stuck? Help me find my downloaded FASTA file and move it into the genomes folder.

Write the FASTA parser

Now that you have real genome data, you can write a script to read it. Biopython's SeqIO module handles the parsing for you. It reads the FASTA file and turns it into a Python object with attributes like the sequence ID, description, and the nucleotide sequence itself.

  • Open analyze.py in VS Code and add this code:
import os
from Bio import SeqIO

# --- Parse the Wuhan-Hu-1 reference genome ---
fasta_file = "genomes/NC_045512.2.fasta"
record = SeqIO.read(fasta_file, "fasta")
print(f"ID: {record.id}")
print(f"Description: {record.description}")
print(f"Length: {len(record.seq)} bp")
print(f"First 100 bases: {str(record.seq[:100])}")

What does this code do?

SeqIO.read() opens the FASTA file and parses it into a SeqRecord object. The .read() method is used when a file contains exactly one sequence record.

record.id gives the accession number, record.description gives the full header text, and record.seq holds the actual nucleotide sequence. Printing the first 100 bases lets you confirm this is real genome data, not an empty or corrupted file.

  • Save analyze.py.

Before you run the script, what do you think the output will look like? How long do you expect the genome to be?

  • Run the script by entering this command in your terminal:
python analyze.py

Your terminal should print four lines: the sequence ID (NC_045512.2), the full description, the genome length (around 29,903 bp), and a string of nucleotide characters like ATTAAAG... for the first 100 bases.

Seeing a FileNotFoundError?

This means Python cannot find the FASTA file at the path genomes/NC_045512.2.fasta. Check that the file is inside the genomes/ folder and that the filename matches exactly (including the .2 version number).

Also confirm your terminal is in the project root folder (the one that contains the genomes/ directory).

Need more help? Help me fix a FileNotFoundError when running my FASTA parser.

Commit the working parser to Git

Your parser works. Time to capture this milestone in your Git history so you can always return to this point.

  • Stage all your changes and commit them by running these commands:
git add .
git commit -m "Add single-genome FASTA parser"
  • Verify the commit was recorded by running:
git log --oneline

You should see two commits listed: your original scaffold commit and the new parser commit.

Only see one commit?

Make sure you ran git add . before git commit. Without staging your files first, Git has nothing to commit.

Need help? Help me figure out why my Git commit did not work.

✔️ Awesome, I've got everything!

Great. Double check you have saved analyze.py and that your Git log shows two commits.

ⓧ I'd like to double check the full code

Here is the complete analyze.py at this point. Make sure your file matches this exactly.

import os
from Bio import SeqIO

# --- Parse the Wuhan-Hu-1 reference genome ---
fasta_file = "genomes/NC_045512.2.fasta"
record = SeqIO.read(fasta_file, "fasta")
print(f"ID: {record.id}")
print(f"Description: {record.description}")
print(f"Length: {len(record.seq)} bp")
print(f"First 100 bases: {str(record.seq[:100])}")

You have just parsed a real viral genome. A single strain is interesting, but the real power of bioinformatics comes from comparison. Next up, you will download four more SARS-CoV-2 genomes and calculate GC content across all five strains.

Calculate GC Content for Multiple Strains

Your parser can read one genome and print its details. That's a solid foundation, but a single isolate doesn't tell you much on its own.

To spot patterns across viral strains, you need data from multiple isolates. In this step, you'll download four more SARS-CoV-2 genomes from NCBI and calculate a key metric called GC content for all five.

In this step, get ready to:
  • Download four more SARS-CoV-2 genome FASTA files from NCBI.
  • Calculate GC content for all five genomes using Biopython.
  • Commit your multi-genome analysis to Git.
Download four more SARS-CoV-2 genomes from NCBI

You already have the Wuhan-Hu-1 reference genome in your genomes/ folder. Now you need four more isolates from different locations and time periods to make the comparison meaningful.

You'll use the same download process from the previous step for each of the following four accessions.

  • Click Send to: in the upper-right area of the record.
  • Select File as the destination.
  • Choose FASTA from the format dropdown.
  • Click Create File.
  • Your browser downloads a file called sequence.fasta. Rename it to MT291826.1.fasta and move it into your genomes/ folder.

Repeat this same process for the remaining three accessions. Open each link, use Send to: to download the FASTA file, rename it, and move it into genomes/.

Once all four files are saved, confirm your genomes/ folder has all five FASTA files by running:

ls genomes/

You should see five .fasta files listed: MT121215.1.fasta, MT291826.1.fasta, MT291830.1.fasta, MW852494.1.fasta, and NC_045512.2.fasta.

Only see one or two files?

Make sure you moved each downloaded file into the genomes/ folder inside your project directory. Check your Downloads folder for any remaining sequence.fasta files that still need to be renamed and moved.

help me find my downloaded FASTA files and move them into the genomes folder

Refactor your script to calculate GC content

GC content measures the percentage of Guanine (G) and Cytosine (C) bases in a DNA or RNA sequence. Biologists use this metric to study gene stability and evolutionary relationships between organisms.

What is GC content?

Every DNA and RNA sequence is made of four nucleotide bases. In DNA, these are Adenine (A), Thymine (T), Guanine (G), and Cytosine (C). GC content is the proportion of bases that are either G or C.

A GC content of 38% means that 38 out of every 100 bases in the sequence are G or C. The remaining 62% are A and T. Comparing GC content across strains can reveal how closely related they are.

Your current script reads a single hardcoded file. You'll replace the entire script with a version that loops through every .fasta file in the genomes/ folder and calculates GC content for each one.

  • In analyze.py, select all the existing code and replace it with the following:
import os
import glob
from Bio import SeqIO
from Bio.SeqUtils import gc_fraction

# --- Parse all FASTA files in the genomes/ folder ---
genome_dir = "genomes"
fasta_files = glob.glob(os.path.join(genome_dir, "*.fasta"))

for fasta_file in fasta_files:
    record = SeqIO.read(fasta_file, "fasta")
    gc = gc_fraction(record.seq) * 100  # Convert to percentage
    print(f"{record.id}: length={len(record.seq)}, GC={gc:.4f}%")

What does this code do?

glob.glob(os.path.join(genome_dir, "*.fasta")) finds every file ending in .fasta inside the genomes/ folder. This means you can add more genomes later without changing the script.

gc_fraction(record.seq) returns a float between 0 and 1 representing the GC ratio. Multiplying by 100 converts it to a percentage so the output is easier to read.

SeqIO.read() works because each FASTA file contains exactly one genome record. The loop processes each file one at a time, printing the ID, length, and GC percentage.

  • Save analyze.py.

Before you run the script, think about what the output will look like. You have five genomes. Do you expect the results to be neatly organized, or just printed line by line?

  • Run the updated script:
python analyze.py

You should see five lines of output, one per genome, each showing the record ID, sequence length, and GC content as a percentage.

What should I see?

Each line looks something like NC_045512.2: length=29903, GC=37.9729%. All five SARS-CoV-2 genomes have similar lengths (around 29,903 bases) and GC content in the 37-38% range.

The output works, but notice the problem. The five lines are printed in whatever order glob found the files. There is no sorting, no summary, and no way to share these results as a clean report. That is the gap the next step will fix.

Seeing a ModuleNotFoundError?

If you see an error mentioning Bio.SeqUtils or gc_fraction, make sure you installed Biopython in Step 1. Run pip install biopython and try again.

If the script prints nothing at all, check that your .fasta files have the correct extension. Files saved as .txt or .fa won't be found by the *.fasta pattern.

help me debug my GC content analysis script

✔️ Awesome, I've got everything!

Great. Double check you've saved analyze.py before moving on.

ⓧ I'd like to double check the full code

Here is the complete analyze.py at this point. Make sure your file matches this exactly:

import os
import glob
from Bio import SeqIO
from Bio.SeqUtils import gc_fraction

# --- Parse all FASTA files in the genomes/ folder ---
genome_dir = "genomes"
fasta_files = glob.glob(os.path.join(genome_dir, "*.fasta"))

for fasta_file in fasta_files:
    record = SeqIO.read(fasta_file, "fasta")
    gc = gc_fraction(record.seq) * 100  # Convert to percentage
    print(f"{record.id}: length={len(record.seq)}, GC={gc:.4f}%")
Commit your multi-genome analysis to Git

Your script now analyzes five genomes instead of one. Capture this milestone in your Git history.

  • Stage and commit your changes by running these commands:
git add .
git commit -m "Add multi-genome GC content analysis"

Why commit now?

Each commit marks a working milestone. If the next step's refactor introduces a bug, you can always roll back to this version where the GC calculations are confirmed working.

Your script can now analyze five viral genomes and calculate GC content for each one. The results are there, but they are just plain text lines with no sorting or structure. Next up, you'll use Pandas to organize these results into a clean, sortable table and export them as a professional CSV report.

Build a Structured Analysis with Pandas

Your script now calculates GC content for all five SARS-CoV-2 strains. But the terminal output is a list of plain-text lines with no sorting or structure. You cannot compare, sort, or hand those raw lines to someone as a professional report.

Pandas is a Python data analysis library that organizes raw data into structured tables called DataFrames. In this step, you will restructure your results into a DataFrame, add summary statistics, and export a CSV report.

In this step, get ready to:
  • Collect genome analysis results into a Pandas DataFrame.
  • Sort the data and calculate summary statistics.
  • Export the results as a CSV report and commit to Git.
Collect results and build a DataFrame

Right now your script prints each genome's GC content and moves on. Nothing is stored, so there is no way to sort or compare the results after the loop finishes. The fix is to collect every result into a list of dictionaries, then hand that list to Pandas.

  • In analyze.py, find the last import line at the top of the file.
  • Find this line:
from Bio.SeqUtils import gc_fraction
  • Add import pandas as pd on the next line, so the imports look like this:
from Bio.SeqUtils import gc_fraction
import pandas as pd
  • Now find the line genome_dir = "genomes".
  • Select everything from that line to the end of the file and replace it with this code:
# --- Parse all FASTA files in the genomes/ folder ---
genome_dir = "genomes"
fasta_files = glob.glob(os.path.join(genome_dir, "*.fasta"))

results = []

for fasta_file in fasta_files:
    record = SeqIO.read(fasta_file, "fasta")
    gc = gc_fraction(record.seq) * 100  # Convert to percentage
    results.append({
        "ID": record.id,
        "Description": record.description,
        "Length (bp)": len(record.seq),
        "GC Content (%)": round(gc, 4)
    })
    print(f"{record.id}: length={len(record.seq)}, GC={gc:.4f}%")

# --- Build a Pandas DataFrame ---
df = pd.DataFrame(results)
df = df.sort_values("GC Content (%)", ascending=False)

print("\n--- GC Content Analysis ---")
print(df.to_string(index=False))

What does this code do?

  • results = [] creates an empty list to store data from each genome.
  • results.append({...}) saves each genome's ID, description, length, and GC percentage as a dictionary. This is the structured data Pandas needs.
  • pd.DataFrame(results) converts that list of dictionaries into a table with named columns.
  • sort_values("GC Content (%)", ascending=False) sorts the table from highest to lowest GC content so you can spot differences at a glance.

Before you run this, what do you think the output will look like compared to the plain text from Step 3?

  • Save analyze.py.
  • Run your script by running this command:
python analyze.py

You should see the familiar per-genome lines first, followed by a clean table under --- GC Content Analysis ---. The table is sorted by GC content, highest to lowest.

Why is this better than plain text?

The DataFrame aligns columns, sorts rows, and gives you access to built-in methods for filtering and statistics. One line of code turned scattered print statements into a proper data table.

Seeing a NameError or ImportError?

  • Check that import pandas as pd appears at the top of your file. A missing import causes a NameError when the script reaches pd.DataFrame.
  • Make sure the column names in your dictionary match exactly, including the parentheses in GC Content (%) and Length (bp).
  • help me debug a NameError or ImportError in my Pandas script
Add summary statistics

A sorted table shows individual values, but it does not tell you the overall picture. Adding mean, minimum, and maximum GC content gives you a quick summary of how the five strains compare.

  • In analyze.py, add the following code below the print(df.to_string(index=False)) line:
# --- Summary statistics ---
print(f"\nMean GC: {df['GC Content (%)'].mean():.4f}%")
print(f"Min GC:  {df['GC Content (%)'].min():.4f}%")
print(f"Max GC:  {df['GC Content (%)'].max():.4f}%")

What does this code do?

Pandas DataFrames have built-in methods like .mean(), .min(), and .max() that calculate statistics on any numeric column. Here you call them on the GC Content (%) column to summarize the entire dataset in three numbers.

  • Save analyze.py and run it again:
python analyze.py

Below the sorted table, you should now see three new lines showing the mean, minimum, and maximum GC content across all five strains.

Seeing a KeyError?

  • A KeyError means the column name in your statistics code does not match the column name in your dictionary. Make sure both use GC Content (%) with exact spelling, spacing, and parentheses.
  • help me fix a KeyError in my Pandas summary statistics
Export to CSV and commit to Git

Your analysis is now structured and summarized, but it only exists in the terminal. Exporting to CSV creates a file you can open in Excel, share with a collaborator, or feed into another pipeline.

  • In analyze.py, add the following code at the very end of the file:
# --- Export to CSV ---
output_file = "gc_analysis_report.csv"
df.to_csv(output_file, index=False)
print(f"\nReport saved to {output_file}")

What does this code do?

  • .to_csv() writes the entire DataFrame to a comma-separated file. The index=False argument prevents Pandas from adding an extra index column you do not need.
  • The CSV file will appear in your project root, right next to analyze.py.

Before you run this final version, what new output do you expect to see at the end of the terminal?

  • Save analyze.py and run the complete script:
python analyze.py

Your terminal now shows the per-genome lines, the sorted table, the summary statistics, and a final line reading Report saved to gc_analysis_report.csv.

  • Confirm the CSV file was created by running:
ls

You should see gc_analysis_report.csv listed alongside analyze.py and the genomes/ folder.

Don't see the CSV file?

  • Make sure you saved analyze.py before running it. Unsaved changes mean the export code never executed.
  • Check that your terminal is in the project folder. Run pwd to confirm you are in the same directory as analyze.py.
  • help me find my missing CSV file
  • Commit this final version to Git by running these commands:
git add .
git commit -m "Add Pandas DataFrame, summary stats, and CSV export"

Why commit now?

This commit captures the finished analysis pipeline. If you extend the script later and something breaks, you can always roll back to this working version.

✔️ Awesome, I've got everything!

Great. Double check you have saved analyze.py and that your Git commit went through.

ⓧ I'd like to double check the full code

Scroll up through this step and confirm each code block is present in your analyze.py, in this order:

  • The five import lines at the top, ending with import pandas as pd.
  • The FASTA parsing section with results = [], the for loop, and results.append({...}) inside it.
  • The DataFrame creation with pd.DataFrame(results), sorting, and table print.
  • The summary statistics section printing mean, min, and max.
  • The CSV export section with df.to_csv(output_file, index=False).

Your analysis pipeline is complete. You went from raw genome files to a sorted, summarized, and exported report. Next up, you will take this even further in the Secret Mission.

Secret mission

Visualize GC Content with a Bar Chart

Your analysis prints a clean table and summary statistics, but numbers alone can hide patterns. Can you add a matplotlib bar chart that makes the GC content comparison instantly visual and save it as a shareable PNG?

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely on your local machine, so there are no ongoing costs. Decide whether to keep your project files, pause to come back later, or delete them entirely.

Resources you used:

  • Project folder on your Desktop containing analyze.py, the genomes/ folder with five FASTA files, gc_analysis_report.csv, gc_content_chart.png, and a Git repository with five commits.
  • Python packages installed via pip: Biopython, Pandas, and matplotlib.

Keep everything running

No action needed. Choose this if you plan to extend your analysis with more genomes or try the Secret Mission.

  • Your project folder, installed packages, and Git history all stay in place.
  • You can reopen the project folder in VS Code at any time and run python analyze.py to regenerate your results.

Pause - I'll come back to this later

Close any open terminals and VS Code windows to free up memory. Your project files and installed packages stay on disk for when you return.

  • Close the terminal window you used during the project.
  • Close VS Code if you have the project open.
  • When you return, reopen the project folder in VS Code and pick up where you left off.

Delete - I don't want to use this again

Remove all project files and uninstall the Python packages you added during this project.

  • Close VS Code and any terminal windows using the project folder.
  • Delete the project folder from your Desktop. On macOS or Linux, run:
cd ~/Desktop
rm -rf [[PROJECT_FOLDER="your project folder name"]]
  • On Windows, run this instead:
cd ~\Desktop
Remove-Item -Recurse -Force [[PROJECT_FOLDER="your project folder name"]]
  • Uninstall the Python packages you installed during this project by running:
pip uninstall biopython pandas matplotlib --yes

What does this command do?

This removes Biopython, Pandas, and matplotlib from your Python installation. The --yes flag skips the confirmation prompt so all three packages are removed in one go.

Python itself stays installed. Only the libraries you added for this project are removed.

Nice Work!

Nice Work!

Nice work! You built a complete bioinformatics analysis pipeline that parses real SARS-CoV-2 genome sequences and compares their GC content across five viral strains.

You've learned how to:

  • Parsed real SARS-CoV-2 genome FASTA files from the NCBI database using Biopython and calculated GC content across five viral strains using gc_fraction().
  • Organized multi-genome results into a sorted Pandas DataFrame with summary statistics and exported a professional CSV report.
  • Tracked every milestone of your analysis with Git commits, building a clear project history from empty scaffold to complete pipeline.
  • Completed an optional Secret Mission to push your analysis skills even further.

Ready to quiz yourself?