Developer Foundations

Separate written instructions, a running program, and visible output.

Predict and run one tiny Python instruction, then change its message.

Understand the edit, save, run, and observe loop.

Change a greeting, save the file, run it again, and confirm the output changed.

See the layers between a physical machine and the software you use.

Sort a keyboard, Windows, Chrome, and a website into the correct layers.

Create a tidy project and recognize common file types.

Create my-first-site/index.html and confirm the editor recognizes HTML.

Read relative and absolute paths and know which folder a command uses.

Connect index.html to images/logo.svg and make the image load.

Use Explorer, Search, Problems, the editor, and the integrated terminal.

Open a whole project folder and make one saved heading change.

Read a shell prompt and run safe navigation commands.

Use pwd, ls, mkdir, and cd to create and enter a practice folder.

See variables as clear names attached to values of different kinds.

Store a score and add two, then compare the number 3 with the text "3".

Recognize conditions, loops, and reusable actions.

Write pseudocode that returns Pass when a score reaches five.

Trace what software receives, changes, remembers, and displays.

Follow a counter click from zero to one and label each stage.

Understand that languages have different jobs and grammar rules.

Match an HTML tag, a CSS selector, and a JavaScript statement to their files.

Understand what turns source code into work the computer can perform.

Match browser to JavaScript, Python to its runtime, and a compiled app to machine instructions.

Understand reused code and why projects lock compatible versions.

Find a package name, version, and lockfile in a sample project.

Build one complete mental picture of a modern app.

Trace a button through the frontend, API, database, response, and updated screen.

Distinguish the network, the web, a browser, and a server.

Arrange browser, internet, server, and response in the correct order.

Read a web address one part at a time.

Label the protocol, domain, path, query, and fragment in a sample URL.

Understand how a browser asks a server for something and receives a result.

Match status 200, 404, and 500 to success, missing resource, and server failure.

Use Elements, Console, and Network as evidence.

Temporarily change a heading in Elements and watch it reset after refresh.

Create a valid page with a title, heading, and paragraph.

Write and open a complete index.html document in the browser.

Choose elements for meaning, not just appearance.

Build a profile card with a heading, paragraph, link, image text, and button.

Style the page predictably with small reusable rules.

Add colour, padding, and a border to a card class.

Create a layout that adapts instead of breaking.

Use max-width, padding, auto margins, and wrapping at phone size.

Add one interaction you can explain from click to screen update.

Make a button increment a visible count from zero to one to two.

Organize code, assets, and simple project instructions.

Build a clear file tree and explain the job of every file.

Know which local version you are looking at and when a browser may reuse old files.

Open the correct local project and compare a normal refresh with a hard refresh.

Extract the message, file, line number, and useful stack frame.

Fix a missing parenthesis using the exact reported location.

Reproduce, isolate, form a hypothesis, change one thing, and verify.

Repair a broken button through one controlled experiment.

Pause and inspect what the program believed at one moment.

Compare a counter value before and after a click.

Inspect a request's URL, method, status, payload, and response.

Find a 404 caused by one incorrect endpoint path.

Understand what each check proves and what it cannot prove.

Run mobile, keyboard, empty-input, console, lint, test, and build checks.

Give backups, local history, and remote collaboration their correct jobs.

Classify a zip backup, local Git repository, and GitHub remote.

Understand Git's three everyday file states.

Edit, inspect, stage, commit, and return to a clean status.

Inspect added and removed lines before accepting or undoing work.

Explain a tiny diff and locate its commit in project history.

Understand the parts of a public open-source project.

Find source files, README, Issues, Actions, license, and history.

Follow a safe collaboration path from branch to reviewed merge.

Create one focused branch and review its pull-request diff.

Make functionality usable without a mouse or sight.

Repair an unlabeled input and a clickable div that cannot be reached by keyboard.

Keep interfaces readable, calm, and usable when text grows.

Test focus, zoomed text, and a reduced-motion fallback.

Protect secrets, validate input, check permissions, and review dependencies.

Move a demo API key out of browser code and into a server environment variable.

Separate experimental work from the system real users depend on.

Choose the preview environment for a risky change and explain why.

Publish deliberately and inspect the experience users actually receive.

Push, inspect a preview, test mobile and links, then promote or revert.

Define the user, outcome, files, and six clear requirements.

Write Given/When/Then checks for a learning-progress button.

Create meaningful page structure and real content first.

Make the page understandable even with its stylesheet disabled.

Add hierarchy, spacing, focus states, and a mobile layout.

Make the page work around 320 pixels wide and on desktop.

Handle a click, update state, and render the result.

Mark one of three learning quests complete and update the count.

Collect evidence for function, mobile, keyboard, accessibility, and security.

Complete a release checklist with a result for every check.

Create a useful commit, README, deployment, and honest reflection.

Publish a working URL and explain every file plus one bug you fixed.