All courses

💡 Why learn problem solving in the age of AI?

“If AI can already write code quickly, why should we still spend time learning algorithms and problem-solving techniques?”

The answer: AI has changed how code is produced, but the ability to understand a problem, design a solution, and judge the result remains indispensable.

Code that runs is not the same as a problem that is solved. Faced with different constraints, data sizes, and use cases, we still need to ask: Is the solution correct? Have we overlooked any edge cases? Is there a more efficient approach?

This course is not about memorizing solution templates, nor does it assume there is only one standard way to think about each problem.

Through a large number of real-world problem-solving examples, we will walk through the process from understanding a problem and exploring different ideas to designing and optimizing a solution. Along the way, we hope you will start to notice the connections between different problems, distill the concepts and techniques worth keeping, and ultimately develop a problem-solving mindset of your own.

🎯 What you will learn

• Problem decomposition and the problem-solving mindset: Learn from real-world examples how to analyze requirements, understand constraints, and find promising directions toward a solution.
• Algorithm design and performance optimization: Explore the principles behind different solutions, understand time and space complexity — for example, the difference between $O(N^2)$ and $O(N \log N)$ — and the trade-offs between different choices.
• AI collaboration and code review: Practice checking AI-generated solutions for correctness, spotting potential issues, and thinking about how to improve them further.
• From problems to real applications: Extend the concepts of algorithms and data structures to real software components, and see how this knowledge applies to real engineering problems.

👥 Who this course is for

• Programming learners: You already have basic programming skills and want to build a stronger problem-solving mindset through real-world examples.
• Programming contestants: You are preparing for or taking part in programming competitions and want to see different problem-solving strategies, broaden your perspective, and gain practical experience.
• Software developers: You want to sharpen your skills in problem analysis, performance optimization, and code review, so that your technical judgment is better grounded.
• AI-assisted developers: You often generate code with AI and want to do more than get an answer — you want to understand, verify, and improve the solutions AI gives you.

📌 Before you start

You should be comfortable with at least one programming language, including basics such as variables, conditionals, loops, functions, and arrays, and be able to write simple programs on your own.

The concepts in this course are not tied to any particular language. Example code will use whichever language suits the problem and context, and you are welcome to follow along in a language you are familiar with.

No advanced mathematical background is required. Necessary concepts such as time and space complexity will be explained through practical examples during the course.

Some problems come from online judges such as LeetCode, as well as officially published past competition problems. The course links to the original problem statements rather than reproducing them, so we recommend creating accounts on the relevant platforms to submit and verify your own solutions. This course does not represent the position of any competition organizer or problem-solving platform.

Units on working with AI will use AI tools to generate solutions and then review them. You can use any AI chat tool or coding agent you are familiar with; some services may require an account or a paid subscription.

Problem-solving ability comes not only from how many algorithms you know, but from how many problems you have seen, how many possibilities you have considered, and whether you can apply past experience to new challenges.

In an era when AI can quickly turn ideas into code, we have more opportunities to try different solutions and keep improving them through implementation and verification. As the barrier to implementing ideas keeps falling, the ability to come up with good ideas and judge whether they are feasible becomes all the more worth developing.

💡 How should you prepare for Web Technologies at Taiwan’s National Skills Competition?

Web Technologies, a job category in the youth category of Taiwan’s National Skills Competition, tests more than a competitor’s programming ability. Competitors must also understand the requirements within a limited time, bring different technologies together, and complete the assigned tasks according to the competition specifications.

Preparing for the competition is also more than studying the test project announced in advance. The official test project used at the competition may change some requirements, so recognizing what has changed, adapting your existing solutions, and making sound technical choices under time pressure are all skills worth practicing.

Being familiar with a test project does not mean you can handle changes to it; finishing your code does not mean every requirement has been implemented correctly.

This course focuses on the software development tasks of the Web Technologies job category in the youth category. Starting with frontend, backend, and database preparation, it covers the concepts, implementation techniques, and common pitfalls worth mastering for the competition.

Beyond the technical foundations, we will work through publicly released past test projects, exploring how to approach different types of tasks — from requirements analysis and technical choices to actual implementation.

We are not trying to memorize as many code templates as possible, nor do we believe each task has only one standard solution. Through hands-on problem solving and repeated review, we hope you will build the ability to handle different task types, technical environments, and changes at the competition.

🎯 What you will learn

• Competition concepts and preparation methods: Learn about the format, assessment approach, and preparation strategy for the Web Technologies job category in the youth category.
• Frontend development and implementation: From HTML, CSS, and JavaScript to various frontend tools, explore layout implementation, interactive features, responsive design, and common frontend issues.
• Backend development and implementation: Explore server-side programming, HTTP, APIs, data processing, and application integration, and understand how to implement backend features according to each task’s requirements.
• Database design and implementation: From table design and relationships to SQL queries and data manipulation, explore how to integrate a database into a complete web application.
• Hands-on work with past test projects: Using publicly released test projects from different years, break down the software development tasks, explore implementation approaches, technical choices, and problem-solving strategies for each module, and, where materials allow, compare the pre-announced test project with the official one.

👥 Who this course is for

• Youth category competitors: You are preparing for the Web Technologies job category and want a more systematic approach to preparation through structured technical topics and hands-on work with past test projects.
• Web Technologies coaches and teachers: You are looking for problem-solving approaches, technical implementations, and preparation methods for different task types to supplement your students’ training and your teaching.
• Developers interested in competition problems: You want to practice requirements analysis, frontend–backend integration, and time-boxed development with real competition tasks.

📌 Before you start

You should have basic knowledge of HTML, CSS, and JavaScript and a general understanding of the web development process.

Depending on the technical topic and the requirements of each past test project, the course uses a variety of programming languages, frameworks, and development tools rather than a single fixed tech stack.

The course mainly covers the software development content of the Web Technologies job category in the youth category, and does not cover visual asset design tasks such as logo design or image creation.

Walkthroughs of past test projects are based on officially published materials that may be used lawfully, and will be added progressively as production continues. This course does not represent the position of the official competition organizers and does not include any unpublished or confidential competition materials.

We hope you will do more than become familiar with one year’s test project, and that through every round of implementation, verification, and review, you will steadily build the ability to face the next unknown test project.

💡 AI tools change every few months — so what should we actually learn?

As AI coding agents mature, we can describe what we want in natural language and have AI generate code, modify features, or even build a simple application — without knowing every programming language or framework.

But AI tools also evolve very quickly. The commands, interfaces, and settings you know today may change within a few months, and new tools and features keep appearing. If learning stops at “how to use a particular tool,” every update may mean starting over.

How tools are operated will keep changing, but the principles behind how agents work, why they misunderstand requirements, and why they may take dangerous actions remain relatively stable.

What information can an agent actually “see” each time it responds? What are prompts, context, and memory? How do Skills, MCP, and tool calling extend what an agent can do? When an agent can read files, run commands, and even connect to external services, who decides its permissions — and who should be responsible for enforcing them?

This course does not focus on how to operate any single tool. Instead, it starts from how AI coding agents fundamentally work and explains the mechanisms behind these common concepts. Although we will demonstrate with several different coding agents, the goal is not to memorize tool-specific steps, but to compare tools, observe the principles they share, and develop judgment that still applies after you switch tools.

We will also run security experiments — such as a simulated malicious Skill and prompt injection — to observe how untrusted content can influence an agent’s behavior.

Beyond the core concepts, small development exercises will have you turn requirements into clear specifications and acceptance criteria, keep a record of every change with Git, and check an agent’s work with tests and diffs. Finally, we will package the requirements and development context into a tool-independent handoff document (a Prompt Pack) and hand it to a different coding agent to continue the work.

We are not trying to build the most elaborate AI development workflow, and we do not believe that using more agents always means greater efficiency. Instead, we start from real problems to understand what agents can do and where their limits are, and build collaboration habits that carry over even when you change tools.

Of course, AI can help us finish simple projects quickly. But if you want to turn them into applications that run and are maintained over the long term, fundamentals such as programming, software architecture, testing, security, and deployment still matter a great deal. These skills do not lose their value because of AI — if anything, they help you understand, verify, and improve what AI produces more effectively.

We hope this course is where you begin developing with AI — not where your software engineering journey ends.

🎯 What you will learn

• How agents work: Understand how a language model, tools, and an execution loop come together to form a coding agent, and how it differs from an ordinary AI chat tool.
• Context and information management: Understand what information an agent actually receives each time it responds, what common terms such as prompts, context, memory, and project instruction files really mean, and how context length limits affect its behavior.
• The shared mechanics of extensions: Starting from tool calling, understand how extensions such as Skills and MCP provide instructions and tools to an agent, and when each kind of extension is appropriate.
• Permissions, trust boundaries, and isolation: Understand who decides and enforces tool permissions. Through repeatable security experiments — such as a simulated malicious Skill and prompt injection — learn why prompts alone cannot protect your development environment, along with the basics of least privilege and environment isolation.
• Requirements and task breakdown: Practice turning vague ideas into clear requirements, constraints, and acceptance criteria, and breaking them down into tasks suited to an agent.
• Verification and version control: Use Git, diffs, and automated tests to check what an agent changed and whether the result is correct, and roll back safely when something goes wrong.
• Handing off across tools: Organize requirements, decisions, and progress into tool-independent handoff documents so that different coding agents can pick up the work.

👥 Who this course is for

• Vibe coding beginners: You want to bring your ideas to life quickly with AI, while building basic habits for verifying results and using these tools safely.
• Computer science and IT students: You want to understand how AI coding agents work, not just how to operate one particular tool.
• Developers new to coding agents: You want to clarify the mechanisms behind common concepts such as prompts, context, Skills, and MCP, and build more effective habits for working with AI.
• Engineers already using AI-assisted development: You deal with constant tool updates and want decision-making approaches and workflows that still apply after you switch tools.
• Learners curious about AI development tools: Through hands-on practice and repeatable experiments, you want to understand what coding agents can do, where their limits are, and how to tell whether their output can be trusted.

📌 Before you start

This course focuses on the fundamentals and practical use of AI coding agents. No in-depth software architecture background is required, but basic programming and computer skills are recommended. Prior experience with Git, the terminal, and software projects will make some of the hands-on content easier to follow.

The course demonstrates with several AI chat tools and coding agents, but these tools are only vehicles for explaining the concepts; the course is not tied to any single programming language, framework, or AI tool. Some activities may require accounts, subscriptions, or API credits for the relevant services.

Security experiments are carried out in isolated environments with simulated data, and do not involve real credentials or unauthorized access to any system.

The interfaces, features, and pricing of AI tools change constantly, so what you see in the course may differ from the version you are using. The course focuses on concepts and methods that do not depend on any particular version, and does not guarantee that any specific workflow will save tokens, reduce costs, or improve development efficiency.

This course also does not aim to fully teach programming, testing, software architecture, or production deployment. If you want to build applications that run and are maintained over the long term, we recommend continuing to strengthen your software engineering fundamentals.

Tools will keep changing, but understanding what an agent sees, what it can do, and how to verify its work is a skill you can carry with you.

💡 Your project is done — now what?

As AI coding tools mature, we can turn ideas into real applications faster than ever. But once a project is finished, the next question is often: Where should it be deployed so that other people can actually use it?

For independent developers, students, and side-project creators, the cost of cloud services can be a real burden. Even if you only want to put your work online, you still have to deal with servers, networking, domains, and deployment workflows.

Oracle Cloud Infrastructure (OCI) offers Always Free services that include a certain amount of free usage, giving us a chance to build our own deployment environment with limited cloud resources.

Starting from OCI’s free tier, this course walks you through setting up a cloud server, deploying containerized applications with Docker, and making your services reachable from the internet through Cloudflare DNS and Tunnel.

Beyond creating cloud resources by hand, we will also take a first look at Terraform and Infrastructure as Code (IaC), exploring how to describe and manage infrastructure with code.

And when your application needs ongoing updates, we will go further with GitHub Actions, get to know self-hosted runners, and build a basic automated deployment workflow that cuts down on the repetitive steps of every release.

Along the way, we will also work with OCI Object Storage, database services, and related settings, and get to know the resources an application may need in a cloud environment.

We are not trying to master every aspect of cloud architecture and operations at once. Instead, through hands-on practice, we aim to understand the steps an application goes through from local development to going live in the cloud, and how the various services work together.

🎯 What you will learn

• OCI’s free tier and cloud resources: Learn the basic Always Free services, their free allowances and limitations, and the compatibility issues to watch out for on ARM64.
• Cloud servers and network configuration: From compute instances, Linux, and SSH to basic networking and firewall settings, set up a cloud environment that can run your applications.
• Terraform and Infrastructure as Code: Get a first introduction to Infrastructure as Code (IaC) and learn how to describe and create OCI cloud resources with Terraform, along with its basic operations.
• Containerized deployment with Docker: Run applications on a cloud server with Docker and Docker Compose, and learn about container networking, data persistence, and basic configuration.
• Exposing services with Cloudflare: Use Cloudflare DNS, Tunnel, and related settings to make services deployed on OCI accessible through your own domain.
• Automated deployment with GitHub Actions: Understand the differences between GitHub-hosted and self-hosted runners, implement a basic CI/CD workflow, and learn the security considerations around runner environments and deployment permissions.
• Cloud data services: Get to know OCI Object Storage and database services, and learn how to integrate these cloud resources into your own applications.

👥 Who this course is for

• Computer science and IT students: You have finished your own programming project and want to deploy it to the cloud so that others can actually use it.
• Independent developers and side-project creators: You want to build your own deployment environment on a limited budget.
• Backend and full-stack developers: You already have application development experience and want to get hands-on with cloud servers, Docker, Terraform, and automated deployment.
• AI-assisted developers: You can already build applications quickly with AI and want to learn how to take them from your local machine to a public cloud environment.

📌 Before you start

You should be comfortable with basic Linux commands and Docker concepts, and have an application ready to practice deploying.

The course uses OCI Always Free resources as its main hands-on environment, but free allowances, service availability, and resource allocation may change with Oracle’s policies and regional capacity. Some operations may also incur additional charges, so please keep an eye on the services you use and your billing settings.

From your local machine to the cloud — let your work move beyond the development environment and go live as a service others can use and share.

💡 Is Clean Architecture really just splitting code into layers?

There are plenty of Clean Architecture tutorials online, from architecture diagrams to project folder structures, each with its own way of implementing it. Yet when we actually start building a system, the same questions tend to come up: Why do we need these layers? How should responsibilities and dependencies be divided? And how do we know whether our design makes sense?

The value of Clean Architecture lies not in how many layers of folders you create, but in managing system complexity through clear responsibility boundaries and the Dependency Rule.

This course uses Go as the main backend language. Moving from Entities and Use Cases to Interface Adapters and Frameworks & Drivers, we will explore the responsibilities, dependencies, and implementation of each layer step by step, and combine them with a spec-first approach, dependency injection, and automated testing to build a system that actually works.

But Clean Architecture is not just for the backend. We will also build a standalone four-layer architecture on the frontend and explore how the same design principles adapt to a different technical environment and different needs.

In addition, each section will incorporate tactical design elements from Domain-Driven Design (DDD) where appropriate — such as Entities, Value Objects, Aggregates, and Repositories — to show how business rules can be expressed and protected across the layers of Clean Architecture, and how the two approaches relate to and differ from each other.

At a time when AI can generate large amounts of code quickly, clear architectural boundaries also give ongoing development a clearer direction, making it easier to understand, verify, and adjust how a system evolves.

We do not aim to apply as many abstractions as possible or to build the most elaborate architecture. Instead, through a complete implementation process, we hope you will understand the reasoning behind each design decision, along with the value and trade-offs it brings.

🎯 What you will learn

• Core principles of Clean Architecture: Understand the Dependency Rule, responsibility boundaries, and layered design, and explore how to decouple core business logic from frameworks and infrastructure.
• Backend architecture and implementation: Implement Entities, Use Cases, Interface Adapters, and Frameworks & Drivers in Go, and understand how the layers work together and how dependencies are wired up.
• Applying DDD tactical design: Gradually introduce Entities, Value Objects, Aggregates, Repositories, and Domain Services into the implementation across the layers, understand how to protect business rules and invariants, and learn when these patterns are worth introducing — and when they are not.
• Specifications and automated verification: Combine OpenAPI, unit tests, integration tests, and Behavior-Driven Development (BDD) to explore how requirements, implementation, and tests can map to one another.
• Clean Architecture on the frontend: Build a standalone four-layer architecture in TypeScript, and understand how to separate business rules, application flow, Presenters, and framework-specific code.
• System integration and continuous evolution: From data persistence and dependency injection to frontend–backend integration, explore how to keep the system’s structure clear and easy to test as features keep growing.

👥 Who this course is for

• Computer science and IT students: You have basic programming and project experience and want to understand how software architecture is designed and applied in practice.
• Backend and full-stack developers: You have built APIs or complete projects and want to improve how you divide responsibilities, manage dependencies, and keep systems maintainable.
• Engineers interested in software architecture: You have come across Clean Architecture, DDD, or SOLID and want to see, through real-world examples, how design principles are put into practice and how DDD tactical design fits together with Clean Architecture.
• AI-assisted developers: You want clearer architectural boundaries so that, while AI speeds up development, you can still understand, verify, and maintain a system that keeps evolving.

📌 Before you start

You should have a basic command of Go and TypeScript syntax, and have built an API or a complete web project before. If you mainly work in another language, being familiar with interfaces and modular design is enough to follow the design principles, though you may need some extra time with Go syntax for the hands-on parts.

You should also have basic experience with HTTP, SQL, and Git, and be able to run a development environment locally with Docker.

On the frontend, the core four-layer architecture will be implemented in TypeScript, with SvelteKit used as the framework layer in the demos. The same design principles apply equally to other frontend frameworks such as React and Vue.

The DDD content in this course focuses on tactical design and is woven into the hands-on work in each section; strategic design is not a focus of the course. This course also does not cover production deployment or operations.

Good architecture is not about following a fixed folder structure, but about understanding why each boundary exists and making sensible design choices based on actual needs.

💡 Why take a fresh look at object-oriented programming?

“Encapsulation, inheritance, polymorphism, abstraction” — you may already know these terms by heart. But when you face complex business logic, ever-changing requirements, and code where a single change ripples through everything, is knowing the definitions really enough?

The value of Object-Oriented Programming (OOP) lies not only in its syntax and features, but in managing code complexity through sensible division of responsibilities, encapsulation, and abstraction.

Especially now that AI can generate large amounts of code quickly, it may be easier than ever to build a system. But as requirements keep growing, code without a sound design foundation can gradually become hard to understand, change, and maintain. AI can speed up development, but keeping a system under control as it keeps growing still deserves careful thought.

Starting from the fundamentals of OOP, this course gradually explores common design approaches such as the SOLID principles, Inversion of Control (IoC), and Dependency Injection (DI), examining the purpose behind each and how to apply them in real development.

Beyond explaining concepts, we will use practical examples to observe the impact of different design choices, and refactor messy code step by step into a structure that is clearer and easier to maintain and extend.

We do not aim to apply as many design patterns as possible, nor do we believe every problem has a single perfect architecture. Rather than memorizing what “good design” looks like, we hope you will understand why a design is the way it is, and when it is worth doing.

🎯 What you will learn

• OOP core concepts and practice: Starting from encapsulation, inheritance, polymorphism, and abstraction, understand the purpose and appropriate use of each through practical examples.
• Design principles and division of responsibilities: Explore the SOLID principles and the dependencies between objects, and learn how IoC and DI can reduce coupling and improve extensibility.
• Hands-on refactoring: Starting from common code smells and messy code, practice analyzing design problems, reassigning responsibilities, and gradually improving readability and maintainability.
• Design thinking for the AI era: Understand how to establish a clear code structure and design boundaries that give AI-assisted development a clearer direction to follow, and learn to evaluate whether a design is ready for future evolution.

👥 Who this course is for

• Computer science and IT students: You are learning object-oriented programming and want to go beyond textbook definitions to understand the concepts and how to apply them through practical examples.
• Programming learners: You have basic programming skills and want to build a foundation in object-oriented programming and software design.
• Software developers: You often deal with complex business logic and want to improve your code structure for better readability, maintainability, and extensibility.
• AI-assisted developers: You want solid software design fundamentals so that AI not only helps you implement quickly, but also keeps developing within a clear architecture and set of design principles.

📌 Before you start

You should be comfortable with at least one programming language, including basics such as variables, conditionals, loops, and functions, and be able to write simple programs on your own. Prior exposure to classes and objects will make the course content easier to follow.

The concepts in this course are not tied to any particular language. You are welcome to follow along in an object-oriented language you are familiar with, and the course will also show how the same design ideas are expressed in different languages where helpful.

For units on working with AI, you can use any AI chat tool or coding agent you are familiar with; some services may require an account or a paid subscription.

This course does not aim to cover every design pattern. Instead, it introduces relevant design patterns, and when to use them, as the practical examples require.

Good design does not necessarily mean more abstraction — it means making well-reasoned, easy-to-understand choices that fit your actual needs at the time.

💡 AI can already write frontend code — so what is left to learn?

As AI coding tools mature, we can now generate large amounts of code from natural language — from page layouts and interactive components to complete web applications.

But being able to generate a website that looks right does not mean truly understanding how it works.

As AI takes on more and more of the implementation work, we may no longer need to spend so much time memorizing every framework’s API. Yet we still need to understand: How does the frontend exchange data with the backend? Where should state live? How is data kept in sync? What are the implications of different rendering strategies? How do we balance performance, security, and user experience?

And as modern web development integrates more server-side capabilities, the frontend and backend work together ever more closely. From data loading and authentication to background push notifications, many seemingly simple features actually involve coordination among the browser, the server, and external services such as push services and identity providers.

What’s more, building a feature does not mean the engineering work is done.

From automated testing, CI/CD, and cloud deployment to analyzing user behavior, tracking errors, and monitoring performance in production, we also need to know how to verify, deliver, and continuously improve a web application that is actually running.

Through a range of practical examples, this course explores the core concepts and practices of modern frontend engineering that are worth understanding. We do not limit ourselves to any particular framework, nor do we try to memorize how to use as many tools as possible. Instead, through problems and hands-on work, we aim to understand the principles, limitations, and design trade-offs behind each technology.

AI can help us implement faster; what we need to learn is how to understand the problem, evaluate solutions, and make sure the final result truly meets the requirements.

🎯 What you will learn

• API integration and real-time communication: From HTTP fundamentals and REST API design conventions to GraphQL queries, understand the characteristics and use cases of different API styles, and explore real-time data updates with WebSocket and Server-Sent Events (SSE).
• State management and data flow: Understand the responsibilities and lifecycles of different kinds of state, and explore the design considerations behind data loading, caching, synchronization, asynchronous operations, and error handling.
• Routing, rendering, and frontend–backend collaboration: From URL state, CSR, and SSR to prerendering, understand when each rendering strategy fits and where the execution boundary lies between the browser and the server.
• Internationalization and content discoverability: Explore multilingual design, SEO, metadata, structured data, and sitemaps, and understand how to make content easier for different users and search engines to find and understand.
• Browser APIs and PWAs in practice: Through examples such as Service Workers, Web Notifications, the Push API, offline caching, and Web Components, explore the capabilities browsers provide and how to apply them in real web development.
• Frontend security fundamentals: Understand the browser security model and common security topics such as XSS, CSRF, CORS, CSP, cookies, and handling sensitive information.
• Testing and user experience: Combine component testing, end-to-end (E2E) testing, accessibility, Core Web Vitals, and Lighthouse to explore how to verify application behavior and evaluate site performance and user experience.
• CI/CD and cloud deployment: Build automated verification and deployment pipelines with GitHub Actions, integrate quality checks such as Lighthouse CI, and use Cloudflare to explore practical topics such as DNS, CDN, environment configuration, caching strategies, and site security.
• Analytics and frontend observability: Use tools such as Umami, Google Analytics, and Sentry to explore web analytics, event tracking, and error monitoring, and understand how to observe application behavior and issues in production.

👥 Who this course is for

• Computer science and IT students: You have basic web development skills and want to understand the core concepts beyond frameworks, along with the engineering practices of a complete web application.
• Frontend developers: You are comfortable with the basics of a framework and want to broaden your engineering knowledge in state management, browser APIs, security, testing, deployment, and observability.
• Full-stack and software developers: You want a deeper understanding of how the browser and the server work together, and of the full journey of a modern web application from development to production.
• AI-assisted developers: You have started using AI to build web pages or applications and want to do more than ship features quickly — you want to understand, verify, and improve the code and the system’s actual behavior.

📌 Before you start

You should have a foundation in HTML, CSS, and JavaScript, and have built a simple application with at least one frontend framework (such as React, Vue, or Svelte). Familiarity with TypeScript, Git, and the terminal will make the hands-on content easier to follow.

The hands-on examples use SvelteKit as the main demonstration framework, but the focus is on concepts and practices beyond the framework, so you are welcome to follow along in a framework you know and compare the approaches.

Some exercises require accounts with third-party services such as GitHub, Cloudflare, and Sentry. The course relies mainly on each service’s free plan, but plan details and usage limits may change with each service’s policies, so please keep an eye on your actual usage.

Support for some browser APIs varies across browsers, operating systems, and devices; the course will also cover the relevant compatibility considerations.

This course does not teach HTML, CSS, or the basic syntax of any particular framework from scratch.

Frameworks and tools will keep evolving, and AI will keep getting better at generating code. But understanding how the Web works, grasping the essence of engineering problems, and making sound technical choices are abilities that remain worth building over time.