2026 – Coding Fundamentals – Teacher Resources

Code Quest · Course Overview | Knowledge Pillars
Code Quest · Course Overview

🧭 Your Code Quest Map

Welcome to Coding Fundamentals! Over 10 units, you’ll go from writing your first line of Python to building real apps that talk to live APIs and store data in real databases — plus everything in between. This page is your map: what you’ll learn, what you’ll build, and how it lines up with the Coding Fundamentals exam.

📋 10 Units · 50 Lessons · 10 Capstones
🐍 Python · Knowledge Pillars CodeSkills Lab
🎓 Florida CTE #9009200 · Grades 6–8

👋 Hey, future coder

By the end of this course, you’ll have built ten of your own programs — a Mad Libs game, a contact manager, a turn-based RPG, a live weather dashboard, an algorithm benchmarking tool, and more. Every unit teaches new skills and ends with a project that uses everything you’ve learned so far. Nothing gets thrown away.

This page shows the whole journey at a glance. Use it to track where you are, see what’s coming, and find which units cover which parts of the Coding Fundamentals exam. The exam has 10 official objectives, and every single one is covered across the course.

🎯 The 10 Coding Fundamentals Exam Objectives

These are the ten things the exam tests. Each card shows what the objective is about, and which unit(s) cover it most directly. Don’t worry about memorizing all of these now — you’ll meet them naturally as you go.

Objective 1
Core programming concepts
Variables, data types, operators, and control structures (if/else, loops). The fundamental building blocks of every program.
📍 Main coverage: Unit 1 · Reinforced: Every unit
Objective 2
Analyze & predict code behavior
Read a code snippet and figure out what it will do — including tracing through loops, conditionals, and function calls.
📍 Main coverage: Units 1–2 · Reinforced: Every unit
Objective 3
Design & implement algorithms
Solve problems by writing out the steps (the algorithm) first, then translating those steps into code. Sorting, searching, factorials.
📍 Main coverage: Unit 3 · Deepened: Unit 9
Objective 4
Write & debug simple programs
Build working programs that meet specific requirements, using clean syntax, good structure, and helpful comments.
📍 Main coverage: Units 1, 2, 4 · Reinforced: Every capstone
Objective 5
Functions & modular code
Break programs into reusable functions with parameters and return values. Understand variable scope (local vs global).
📍 Main coverage: Unit 4 · Reinforced: Units 5–10
Objective 6
Basic data structures
Use lists, dictionaries, and tuples to store and organize collections of data — adding, removing, searching, and looping through them.
📍 Main coverage: Unit 5 · Reinforced: Units 6–10
Objective 7
Debugging techniques
Read error messages, use print statements to find bugs, and develop a systematic way to track down problems in your code.
📍 Main coverage: Units 2, 4 · Reinforced: Every unit
Objective 8
Software Development Lifecycle
Understand the stages every real piece of software goes through: Plan → Code → Test → Fix → Maintain — and why each one matters.
📍 Main coverage: Unit 4 · Applied: Every capstone after
Objective 9
Computational thinking
The four pillars: decomposition, pattern recognition, abstraction, and algorithmic design. The way computer scientists actually think.
📍 Main coverage: Unit 9 · Practiced: Every unit
Objective 10
Ethical & legal considerations
Intellectual property and copyright, user privacy, responsible technology (including AI), and the real-world impact of the code you write.
📍 Main coverage: Unit 10

📊 At-a-Glance: Which Units Cover Which Objectives

A quick visual reference. A solid gold cell means the unit covers that objective in depth. A bordered cell means the unit introduces or reinforces it.

Unit Obj 1 Obj 2 Obj 3 Obj 4 Obj 5 Obj 6 Obj 7 Obj 8 Obj 9 Obj 10
Unit 1 · Building Blocks ● ◐ — ◐ — — ◐ — — —
Unit 2 · Loops & Tracing ◐ ● — ● — — ● — — —
Unit 3 · Making a Plan ◐ ◐ ● ◐ — ◐ — — ◐ —
Unit 4 · Clean Code & Functions ◐ ◐ — ● ● — ● ● — —
Unit 5 · Data Structures ◐ ◐ — ◐ ◐ ● — ◐ — —
Unit 6 · Files, JSON & Errors — — — ◐ ◐ ◐ ● ◐ — —
Unit 7 · Classes & Objects — — — ◐ ● ◐ — ◐ ◐ —
Unit 8 · APIs & The Web — — — ◐ ◐ ◐ ◐ ◐ ◐ —
Unit 9 · Computational Thinking — ◐ ● ◐ ◐ ◐ — ◐ ● —
Unit 10 · Databases & Ethics — — — ◐ ◐ ◐ — ◐ ◐ ●
● Deep coverage — the unit is built around this objective ◐ Introduced or reinforced — practiced in lessons and labs

🚀 What You’ll Build, Unit by Unit

Every unit teaches new skills and ends with a project that uses everything you’ve learned so far. The story arc: a Mad Libs game grows up across Units 1–4, then a Contact Vault grows up across Units 5, 6, and 10. By Unit 10 you’ll have built ten complete programs.

Unit 1
Building Blocks of PythonVariables · Types · Operators · If/Else

You’ll start with absolutely no coding experience — and end the unit having written real Python. You’ll learn the four pieces every program is made of: variables (named boxes for data), data types (numbers, text, True/False), operators (math and comparisons), and conditionals (if/elif/else for decisions).

What you’ll build
Mad Libs — Your First Interactive Game
A program that asks the user for words (a noun, a verb, an adjective…), drops them into a silly story, and prints the result. It uses input() to talk to the player, f-strings to build the story, and if/elif/else to give it a custom ending based on the words chosen.
Exam objectives covered
1 · Core concepts 2 · Trace code 4 · Write programs 7 · Debug
Unit 2
Loops & Code Detective Workfor / while loops · Trace tables · Debugging

Repeating code by copy-pasting it three times? There’s a better way. You’ll meet for loops and while loops, which let one line of code run as many times as you want. You’ll learn to trace through code on paper — predicting what variables hold at every step — and pick up a 3-step debugging method for finding broken code.

What you’ll build
Mad Libs 2.0 — Replay Edition
Your Unit 1 game gets a loop upgrade. A for loop runs 3 rounds inside one game with different stories each time. A while loop wraps the outside so players can hit “play again” as many times as they want — just like every real game.
Exam objectives covered
1 · Core concepts 2 · Trace code 4 · Write programs 7 · Debug
Unit 3
Making a PlanAlgorithms · Flowcharts · Bubble Sort · Factorials

Great coders plan before they code. You’ll learn what an algorithm is (a clear step-by-step plan), draw flowcharts with the four standard shapes, watch Bubble Sort happen in slow motion to see how computers sort lists, and explore factorials — a tiny piece of math that connects loops, multiplication, and a famously sneaky way to crash a program.

What you’ll build
Mad Libs 3.0 — Sorted Edition
Your game now collects every story it generates into a list, then sorts them alphabetically at the end using Python’s sorted(). You’ll write the algorithm in plain English first (a real comment block at the top of the file), then translate it line-by-line into Python.
Exam objectives covered
3 · Algorithms 4 · Write programs 6 · Data structures 9 · Comp. thinking
Unit 4
Clean Code & FunctionsFunctions · Scope · Debugging · SDLC

This is the unit that takes you from “I can write code that works” to “I can write code other people can read.” You’ll learn functions — the single biggest tool that separates beginner code from professional code — plus how variable scope works, systematic debugging, and the Software Development Lifecycle (Plan → Code → Test → Fix → Maintain) that every real software team follows.

What you’ll build
Mad Libs 4.0 — Modular Edition
The biggest Mad Libs upgrade yet. Your game gets rebuilt around clean named functions: one to collect words, one to build the story, one to display the result. You’ll walk through every SDLC stage and end with code that looks like something a professional would ship.
Exam objectives covered
4 · Write programs 5 · Functions 7 · Debug 8 · SDLC
Unit 5
Data StructuresLists · Dictionaries · Tuples · Strings

Until now, a variable held one thing. Unit 5 teaches you to hold many things at once — and pick the right shape for the job. You’ll go deep on lists, meet dictionaries (the most useful data structure in all of programming), use tuples for fixed groups of values, and treat strings like the data they really are. Lists of dicts is how every modern app — Spotify, Instagram, your phone’s contacts — actually stores information.

What you’ll build
Contact Vault — Your Mini Database
A working contact-management app. The vault is a list of contacts, each contact is a dict with name/phone/email and a tuple for (city, state). Add, remove, search, sort — all wrapped in clean functions from Unit 4.
Exam objectives covered
6 · Data structures 5 · Functions 4 · Write programs 8 · SDLC
Unit 6
Files, JSON & ErrorsFile I/O · JSON · try/except · Modules

This is the unit that turns a script into a real application. You’ll learn to save data to files and reload it later, use JSON (the data format every web app on the planet speaks), catch errors with try / except so missing files don’t crash your program, and use Python modules — both built-in ones and your own.

What you’ll build
Persistent Contact Vault
Take your Unit 5 Contact Vault and give it memory. Contacts save to a JSON file when you quit and load back automatically the next time you launch. A “last modified” timestamp shows when the vault was last updated. The result is a real, persistent app — not just a script.
Exam objectives covered
7 · Debug (errors) 4 · Write programs 5 · Functions 6 · Data structures 8 · SDLC
Unit 7
Classes & ObjectsObject-Oriented Programming · Inheritance

Code stops thinking about data and functions as separate things — they combine into objects. You’ll write your first classes (blueprints), create objects from them, learn how self and __init__ work, and use inheritance to share code between related classes without copying. This is how nearly every video game and app on your phone is actually structured.

What you’ll build
Quest Heroes — A Turn-Based RPG
A Character base class with health, attack, and defense. Warrior and Mage subclasses with their own abilities (sword strikes, fireballs). A Battle class that runs combat between two heroes. JSON persistence so your roster survives between sessions. Multiple cooperating objects — same architecture every shipped game uses.
Exam objectives covered
5 · Functions (methods) 4 · Write programs 6 · Data structures 8 · SDLC 9 · Comp. thinking
Unit 8
APIs & The WebHTTP · requests · JSON parsing · Caching

Your code stops being alone on your computer and joins the rest of the internet. You’ll learn what APIs are, how HTTP requests actually work, use the requests library to pull live data into your program, handle network errors gracefully, and cache responses so you don’t hammer servers. The same three-line pattern works against thousands of public APIs.

What you’ll build
Weather Dashboard
A command-line weather tool that talks to two real public APIs: one to turn a city name into coordinates, another to fetch the live forecast. Wraps responses in a WeatherReport class. Caches results to disk. Saves favorite cities. Handles bad city names, network outages, and rate limits without crashing. A real app you’d actually use.
Exam objectives covered
4 · Write programs 5 · Functions 6 · Data structures 7 · Debug 8 · SDLC 9 · Comp. thinking
Unit 9
Computational ThinkingSearch · Sort · Binary · Logic · Sets

This is the unit where you become a computer scientist. You’ll learn the four pillars of computational thinking — decomposition, pattern recognition, abstraction, algorithmic design — and see how two different algorithms can solve the same problem at wildly different speeds. Plus the math underneath everything: binary numbers, logic gates, and Python’s set type.

What you’ll build
Algorithm Playground — A Benchmark Tool
A real CLI tool that races algorithms against each other. Three Python files: algorithms.py, bench.py, and main.py. Pick a list size, pick a comparison, watch step counts and timings prove the difference between linear and binary search — or bubble sort vs Python’s built-in sorted().
Exam objectives covered
3 · Algorithms 9 · Comp. thinking 4 · Write programs 5 · Functions 6 · Data structures 8 · SDLC
Unit 10 · 🏁
Databases & EthicsSQLite · CRUD · SQL · Responsible Coding

The course finale. Two big topics that every working developer needs: databases (the right tool for storing real data) and ethics (the responsibilities that come with writing code that affects people). You’ll use SQLite, learn SQL (the language of databases), perform CRUD operations (Create, Read, Update, Delete), and write a real ethics statement for your project.

What you’ll build · Course Capstone
Contact Vault — SQL Edition + Ethics Statement
Take your Unit 6 Contact Vault and migrate it from JSON storage to a real SQLite database. Same features your users love, professional-grade machinery underneath. Then write a meaningful ETHICS.md documenting how you collect, store, and protect user data. The grand finale of Code Quest.
Exam objectives covered
10 · Ethics & legal 4 · Write programs 5 · Functions 6 · Data structures 8 · SDLC 9 · Comp. thinking

🌟 What you’ll have built by the end

Ten complete programs. Every one runs. Every one is something you can show off to family, friends, and on a portfolio.

  • Mad Libs — the original interactive game
  • Mad Libs 2.0 — with replay loops
  • Mad Libs 3.0 — story-sorting edition
  • Mad Libs 4.0 — modular & professional
  • Contact Vault — your mini database
  • Persistent Contact Vault — saves to disk
  • Quest Heroes — turn-based RPG
  • Weather Dashboard — live API data
  • Algorithm Playground — head-to-head benchmarks
  • Contact Vault SQL Edition — real database + ethics
💡 One more thing. Every project builds on the last. Don’t skip ahead — and don’t worry if a unit feels hard. Every coder, from beginner to senior engineer, gets stuck. Getting unstuck is half the job. Read the error messages, try the debugging steps, ask for help. You’ve got this. 🚀
Not Enrolled

Course Includes

  • 11 Lessons
  • 10 Topics