A structured, project-first track where students learn the three languages every website is built from, then publish real sites to the internet that anyone can visit.
For students who want to build things other people can actually use, this program teaches the three languages every website is made of — HTML for structure, CSS for appearance and JavaScript for behaviour — using the same editor, browser tools and publishing workflow professional developers use every day. Students progress from a single styled page to a multi-page interactive site deployed to a live URL, learning to read errors, organise files and cut scope along the way.
Students learn what a website actually is: a set of files a browser reads and draws. They open their first HTML file locally, meet the browser's developer tools, and see the direct link between the file they edit and the page in front of them. Focus is on removing the mystery before any syntax is taught.
Students build their first real page using headings, paragraphs, lists, links and images. They learn how tags nest inside each other, why structure matters for both readers and search engines, and how to spot the effect of a tag left unclosed.
Students give the page colour, typography and spacing. They learn selectors, properties and values, and see how a single stylesheet can restyle every page of a site at once — the first moment the work feels designed rather than typed.
Students learn that every element is a box with padding, a border and a margin. They build a reusable card component and discover that most spacing problems are box model problems, which makes them fixable rather than mysterious.
Students arrange elements into rows and columns, align and distribute them, and build a working navigation bar and image gallery. This is where pages stop being a vertical stack and start having a deliberate layout.
Students use media queries so the same page works on a laptop and a phone. They resize the browser, find what breaks, and fix it — learning that most visitors will arrive on a small screen and the site has to meet them there.
Students split their work across several linked pages sharing one stylesheet, and learn to organise files and folders so a project stays understandable as it grows past a handful of files.
Students finish and present a complete multi-page personal site. They explain the structure and design choices they made, demonstrate it at phone and laptop size, and give constructive feedback on their classmates' work.
Students meet variables, numbers, text and the browser console. They write their first script that changes what is on the page, and practise reading the console to find out what went wrong instead of guessing.
Students connect code to what a visitor does — clicking, typing, submitting. They build buttons and inputs that respond, learning the single pattern that sits underneath every interactive page on the web.
Students use if and else so a page behaves differently depending on the situation, and build a form that checks its own input and explains the problem before accepting an answer.
Students store lists of data and render them onto the page automatically. They see immediately why writing each item out by hand stops working, and how a loop keeps the code short as the list grows.
Students package behaviour into reusable functions with parameters, then return to earlier projects and simplify them. Focus is on naming things clearly and not repeating the same code in three places.
Students create, change and remove elements entirely from code, building a to-do list that updates as it is used. This is the lesson where a page stops being a document and becomes an application.
Students load JSON with fetch and display it on the page, so a site can show information that comes from somewhere else rather than being typed in by hand. They also handle the case where the data fails to arrive.
Students present an interactive web app, demonstrate each feature, and walk the class through the code that makes it work — explaining not just what it does but why they built it that way.
Students learn version control: commits, history, and why professional work is never a folder full of files named final-v2. They put an existing project under version control and read back their own history.
Students publish to GitHub Pages or Netlify and get a real URL. They send that link to someone else and watch their site open on a device they do not control — usually the most memorable lesson of the level.
Students build a consistent type scale, colour set and spacing rhythm instead of choosing values ad hoc, and learn the accessibility basics — contrast, alt text, keyboard navigation — that decide whether everyone can use the site.
Students build a form that validates input, shows clear feedback, handles errors gracefully, and connects to a service that actually collects the responses.
Students learn why pages feel slow — oversized images, too many requests, blocking scripts — then measure their own site in the browser and make concrete changes that speed it up.
Students scope their own final site into phases, decide what the first version must contain, and write down what they are deliberately leaving out. Learning to cut scope is what makes the project finishable.
Independent build time with instructor coaching. Students implement their plan, debug their own problems, and practise asking for help the way a developer does: with the error, the context and what they already tried.
Students present a deployed site, walk through the code and the decisions behind it, gather feedback from the class, and leave with a written plan for the next version.
A multi-page site about the student — structured with HTML, styled with CSS, and working properly on a phone as well as a laptop.
A card and gallery layout built with Flexbox that rearranges itself sensibly at every screen width.
A working application where items are added, completed and removed entirely from JavaScript, updating the page as it is used.
A page that loads information from a JSON file and renders it automatically, including a sensible message when the data fails to load.
A form that validates what is typed, gives clear feedback, and delivers real submissions rather than pretending to.
A site of the student's own design, planned in phases, version-controlled on GitHub and published to a URL anyone can open.
Web development is the layer underneath most of what your child already uses. Apps, dashboards, online shops and most AI tools are delivered through a browser, and HTML, CSS and JavaScript are what they are made of. It is also the fastest feedback loop in programming: change a line, refresh, see it — which is why the web is where most self-taught developers begin.
Real syntax, real files, real error messages. Learning to read what the browser is complaining about is part of the training rather than an obstacle to it.
Save the file, refresh the page, see the result. The loop is short enough to keep a beginner engaged through the difficult early weeks.
Every level finishes with something openable on a phone. There is no ambiguity about whether the work got done.
The same languages carry into app development, startup projects and any future framework. Nothing learned here has to be unlearned later.
Students learn that an error message is information, not failure. They read it, locate the line, and form a hypothesis before changing anything.
Nesting, hierarchy and organisation in HTML transfer directly to organising essays, notes and arguments at school.
Spacing, alignment, contrast and typography become things the student notices and can control, rather than things that just happen.
Isolating a problem, testing one change at a time, and undoing what did not help is a general problem-solving habit, not a coding trick.
Understanding that information has a shape — lists, records, fields — underlies spreadsheets, databases and most later technical work.
Committing work in meaningful steps and being able to go back teaches a way of working that removes the fear of breaking things.
Scoping a project, cutting what will not fit, and getting it live is a complete cycle most students have never been through before.
Building pages that are correctly structured for readers, browsers and search engines alike.
Flexbox, the box model and media queries — laying out a page that works at any screen size.
Variables, conditions, loops, functions, events and the DOM: general programming, learned in the browser.
Arrays, JSON and fetch — displaying information that comes from outside the page itself.
Commits, history and version control as a normal part of how work gets done.
Taking a project from a local folder to a live address other people can visit.
No. Level 1 assumes nothing beyond being able to use a computer. Students who have done Scratch or GDevelop will recognise the concepts and move faster, but they are not required.
It is real. Students write HTML, CSS and JavaScript by hand in a professional editor, use the browser's developer tools, and deploy with Git. There is no simplified layer in between.
The tools overlap, but the goal differs. This program builds depth in web development itself; Startup Foundations points those same tools at a product with real users and adds validation, scoping and feedback.
A laptop or desktop with Chrome. Every tool used in the program is free, and everything they build can be opened on your own phone.
Each level ends with a showcase, and from Level 3 the work is on a public URL and in a GitHub history you can look through at any time.
Book a free trial lesson and see whether this is the right fit for your child.
Phone/WhatsApp/Zalo: 0902 776 753
Email: hello@techtutor.academy
Website: techtutor.academy
Hours: Mon-Fri 8:00-21:00 | Sat-Sun 8:00-20:00