Language Foundations
Syntax is the easy part. These modules focus on how variables, scope, and control flow behave in practice, using exercises where a small change in structure produces a visible difference in output.
Course pages on this site describe learning modules, not guarantees of employment or certification. Where a module lists a tool or language, it means the material covers that tool at the level stated, nothing more. Completion dates depend on your own pace, and any project work you submit stays yours.
Syntax is the easy part. These modules focus on how variables, scope, and control flow behave in practice, using exercises where a small change in structure produces a visible difference in output.
Branching, commit hygiene, and conflict resolution taught against a shared repository rather than a solo sandbox. The awkward cases get their own lessons: reverting a merge, recovering work with reflog, reviewing a pull request that grew too large.
How to read a stack trace top-down, isolate the frame that matters, and form a hypothesis before touching the code. Includes async boundaries, minified production builds, and errors that surface far from their cause.
When to split a function, when duplication is cheaper than another layer of indirection, and how naming and test friction tell you more about a routine than its length ever will.
HTML structure, CSS layout, and browser behavior explained through small buildable pages. Emphasis on accessibility, responsive layout, and understanding what the browser is doing before reaching for a framework.
Request and response cycles, JSON handling, error states, and the difference between a failing endpoint and a failing assumption. Exercises use public data sources so results stay verifiable.
Modules can be taken in sequence or picked individually. Each one lists its prerequisites and the practical skills it covers, so you can plan a route through the material that matches what you need next.
Each track is a set of modules you work through in order. Some people start with the fundamentals track and move on once they can read code comfortably; others jump straight into the development track because they already write scripts at work. Pick the one that matches where you are right now, not where you think you should be.
Syntax, data types, control flow, and how to debug your own mistakes. Built for people who have never written a line of code or who learned by copying snippets and want the reasoning behind them. Modules run in short sessions with exercises after each one.
Start with fundamentalsVersion control, code review, testing, and structuring a project so it survives more than one contributor. Assumes you can already write working code. Heavier on workflow than on syntax, with repository exercises you keep after the track ends.
See the development trackCommand line, file systems, networking basics, and the everyday tooling that surrounds software work. Useful if you are moving from a non-technical role into a team that ships software, or if you support developers and want to understand what they actually do.
Review the IT trackA single scoped build you complete across several weeks, with checkpoints and written feedback on your commits. Meant as a capstone after one of the tracks above, though you can enter directly if you already have working experience and want structured review.
Ask about the project moduleEvery module follows the same route: you bring a goal, we map it to a track, and you leave each stage with something you can actually run, read, or hand to a reviewer.
You tell us what you want to build or fix — a small API, a front-end layout, a script that keeps breaking. We look at your current comfort level with syntax, tooling, and the terminal, then point to the track that closes the gap fastest.
Tracks run from foundational coding concepts up through development practices and deployment basics. Each one lists its modules, the languages involved, and roughly how many weeks of part-time study it takes to finish.
Modules build on each other on purpose. You read the concept, write code against a small exercise, then compare your solution to a reference implementation with notes on why certain choices were made.
At the end of a module you submit your work. An instructor reads the code, flags structural problems, and answers the questions that came up while you were writing it — usually within a couple of working days.
The final stage is a project you choose. It gets scoped, built, and reviewed like real work: version control, a README, and a short walkthrough of the decisions you made along the way.