SkillPath Africa
Beginner → Professional

Web Development for Beginners: Build, Test and Launch Websites

Start from web fundamentals and progress through HTML, CSS, responsive layouts, and JavaScript. Practise with real build tasks, learn to debug and test your work, and finish by publishing a polished, accessible website you can show in a portfolio.

80 lessons · 4 levelsKSh 500

Every lesson comes with written notes, a practice task and a knowledge check.

Watch the first lesson free

Prepare a Portfolio-Ready Project — Present the problem, design decisions, working result, and limitations honestly.

Create a free account to watch it. No payment needed.

On a limited data plan? Tap the gear icon (⚙️) in the video player and choose 480p or lower — standard-definition video uses a fraction of the data HD does and still looks fine on a phone.

What you'll build

Build and Publish a Responsive Business Website

Build a mobile-first website for a fictional or consenting small business. Include semantic HTML, responsive CSS, accessible navigation, a working interactive feature using JavaScript, validated form behaviour or a clearly labelled demo form, clear contact calls to action, and appropriate page metadata. Test keyboard use, mobile and desktop layouts, broken links, console errors, and empty or invalid inputs. Publish the site, verify the live URL, and write a short case study explaining your choices and known limitations. Do not expose secrets or collect real personal data in a demo.

Level 1 — Web Foundations

Understand browsers, the web, developer tools, and the problem-solving habits used throughout web development.

Module 1 — How the Web Works

  • Lesson 1 — What Happens When You Visit a Website· 5 min· ~38 MB

    Follow the whole journey from typing a URL to seeing a page — the request and response cycle that underpins everything else.

    • Describe the request/response cycle in plain terms
    • Identify the main players: browser, DNS, server, response
    • Explain why a page can load slowly or fail at different points in that chain
  • Lesson 2 — How the Internet Works: Clients, Servers, and Networks· 1h 43m· ~740 MB

    The client-server relationship underneath every website — who asks, who answers, and how those machines find each other at all.

    • Define client and server and give an example of each
    • Explain what an IP address does
    • Describe at a high level how data travels between networks
  • Lesson 3 — Domains, DNS, and Web Hosting· 4 min· ~26 MB

    How a human-friendly domain name gets connected to an actual server, and what web hosting really means when you go to publish your own site.

    • Explain what a domain name is and how it maps to an IP address
    • Describe what DNS does in that process
    • Explain what web hosting provides and why you need it to publish a site
  • Lesson 4 — How Browsers Render a Web Page· 2 min· ~16 MB

    What the browser actually does with the HTML, CSS, and JavaScript it receives — and why that order explains a lot of layout bugs.

    • Describe how the browser parses HTML into the DOM
    • Explain where CSS and JavaScript fit into the rendering process
    • Explain why render order can cause visible layout shifts
  • Lesson 5 — HTTP and HTTPS Basics· 7 min· ~47 MB

    The protocol that carries every request and response — and what the S in HTTPS actually protects.

    • Explain what HTTP is and what a request and response contain
    • Explain what HTTPS adds and why it matters
    • Recognise common status codes like 200, 404, and 500

Module 2 — Developer Tools & Workflow

  • Lesson 1 — Installing and Setting Up VS Code· 39 min· ~278 MB

    Install Visual Studio Code and configure it for web development — the editor you'll write nearly every line of code in.

    • Install VS Code on your operating system
    • Navigate the editor: explorer, tabs, and the integrated terminal
    • Install a useful extension and understand what extensions do
  • Lesson 2 — Browser Developer Tools (Chrome DevTools)· 1h 15m· ~539 MB

    Open the browser's built-in developer tools to inspect any page's HTML, edit CSS live, and read errors in the console.

    • Open DevTools and inspect an element on any live web page
    • Edit CSS in the Elements panel and see changes instantly
    • Read errors and log messages in the Console panel
  • Lesson 3 — Command Line and Terminal Basics· 45 min· ~326 MB

    Learn the handful of terminal commands that web development actually requires — navigating folders, creating files, and running tools.

    • Navigate the file system using cd, ls/dir, and pwd
    • Create folders and files from the command line
    • Explain why developers use the terminal instead of only a file explorer
  • Lesson 4 — Git Basics: Tracking Your Changes· 1h 9m· ~498 MB

    Use Git to save snapshots of your project so you can always go back — the safety net every developer relies on.

    • Explain what version control is and why it matters
    • Initialise a repository and make your first commit
    • Use git status and git log to see what's changed
  • Lesson 5 — GitHub Basics: Repositories, Push, and Pull· 12 min· ~87 MB

    Put your Git projects online with GitHub — where developers back up code, show their work, and collaborate.

    • Create a repository on GitHub and connect it to a local project
    • Push local commits to GitHub and pull changes back down
    • Explain how GitHub differs from Git itself

Module 3 — Thinking Like a Developer

  • Lesson 1 — HTML, CSS, and JavaScript: What Each One Does· 18 min· ~133 MB

    The single most important mental model in web development: structure, style, and behaviour as three separate layers.

    • Explain the role of HTML, CSS, and JavaScript separately
    • Identify which language is responsible for a given feature on a page
    • Describe how the three work together to make one web page
  • Lesson 2 — How to Read Technical Documentation· 17 min· ~123 MB

    Move beyond tutorials by learning to read official documentation — the skill that lets you solve problems no video covers.

    • Find the official documentation for a language or tool
    • Read a documentation entry: syntax, parameters, and examples
    • Explain why documentation beats tutorials for solving specific problems
  • Lesson 3 — The Debugging Mindset· 33 min· ~235 MB

    A systematic approach to broken code — how to find the actual cause instead of guessing and changing things at random.

    • Read an error message and extract the useful information from it
    • Use console.log and browser DevTools to narrow down a bug
    • Apply a systematic process: reproduce, isolate, fix, verify
  • Lesson 4 — Responsive and Mobile-First Design Basics· 23 min· ~167 MB

    Why most of your users are on phones — and what that means for how you build every page from the start.

    • Explain what responsive design means
    • Describe the mobile-first approach and why it's recommended
    • Identify how a layout should adapt between phone and desktop
  • Lesson 5 — Web Accessibility Basics· 38 min· ~270 MB

    Learn practical foundations for making pages usable with screen readers, keyboards, zoom, and other ways of browsing.

    • Explain how semantic HTML supports people using assistive technology
    • Choose meaningful alt text or an empty alt attribute for decorative images
    • Check keyboard access, visible focus, and text contrast

Level 2 — HTML: Structure and Content

Build meaningful page structure with headings, links, images, forms, and semantic elements.

Module 4 — HTML Structure & Text

  • Lesson 1 — Your First HTML Page· 9 min· ~68 MB

    Write the HTML boilerplate every page starts with — doctype, html, head, body — and open your own page in a browser.

    • Write a valid HTML boilerplate from memory
    • Explain what doctype, head, and body each do
    • Open a local .html file in a browser and see your changes
  • Lesson 2 — Adding Content: Text and Paragraphs· 7 min· ~49 MB

    Put real content on the page with paragraphs, and see how the browser treats whitespace differently from how you typed it.

    • Add paragraphs of text with the <p> element
    • Explain why extra spaces and line breaks in your code collapse in the browser
    • Build up a page with several blocks of real content
  • Lesson 3 — Headings and Hierarchy· 9 min· ~63 MB

    Use HTML headings to create a clear, logical outline for page sections and subsections.

    • Use h1 through h6 to express the hierarchy of page sections
    • Choose heading levels by document structure rather than visual size
    • Explain why a logical heading sequence helps navigation
  • Lesson 4 — Lists: Ordered, Unordered, and Nested· 6 min· ~45 MB

    Build bulleted and numbered lists, and nest one inside another for sub-points.

    • Build unordered (<ul>) and ordered (<ol>) lists
    • Explain when order is meaningful and which list to use
    • Nest a list inside another list item
  • Lesson 5 — HTML Attributes· 1h 1m· ~437 MB

    Attributes are the extra information you attach to a tag — href, src, alt, class. Learn how they're written and why nearly every useful element needs them.

    • Explain what an attribute is and where it goes in a tag
    • Write attributes with correct name="value" syntax
    • Identify common attributes: href, src, alt, class, id
  • Lesson 6 — Semantic Meaning: Strong and Em· 4 min· ~31 MB

    Why <strong> and <em> are not just bold and italic — and why choosing the meaningful tag matters for accessibility.

    • Distinguish <strong>/<em> from <b>/<i>
    • Explain what semantic markup means and who benefits from it
    • Choose the right element based on meaning rather than appearance

Module 5 — Links, Images & Media

  • Lesson 1 — Links and Anchor Tags· 4 min· ~30 MB

    The element that makes the web a web — anchor tags, href, and opening links in a new tab.

    • Create a link with <a> and href
    • Link to an external site and to another page in your own project
    • Use target="_blank" and know when it's appropriate
  • Lesson 2 — Relative vs Absolute File Paths· 15 min· ~107 MB

    Why a link works on your machine but breaks once the site is live — the difference between relative and absolute paths.

    • Explain the difference between a relative and an absolute path
    • Navigate up and down folders with ../ and folder/
    • Diagnose a broken image or link caused by a wrong path
  • Lesson 3 — Adding Images· 4 min· ~28 MB

    Put images on the page with the img element — and write alt text that actually does its job.

    • Add an image with <img>, src, and alt
    • Write alt text that describes the image's purpose
    • Explain why <img> needs no closing tag
  • Lesson 4 — Embedding Video· 5 min· ~33 MB

    Add a video player to your page with the video element, and understand why multiple source formats exist.

    • Embed a video with the <video> element
    • Use the controls attribute and understand autoplay's downsides
    • Explain why several <source> formats (mp4, webm, ogg) are offered
  • Lesson 5 — Embedding Audio· 5 min· ~38 MB

    The audio element — adding music, podcasts, or sound clips to a page.

    • Embed audio with the <audio> element
    • Apply the controls attribute so playback is usable
    • Recognise common audio formats used on the web
  • Lesson 6 — The Head Section: Title, Charset, and Meta Tags· 4h 8m· ~1782 MB

    The invisible part of your page that controls the browser tab, character encoding, mobile scaling, and your search-result snippet.

    • Set the page <title> and explain where it appears
    • Explain what charset and the viewport meta tag do
    • Write a meta description and say where it's used

Module 6 — Forms & Semantic HTML

  • Lesson 1 — Building Your First Form· 25 min· ~180 MB

    The form element end to end — action, method, and what actually happens when someone hits submit.

    • Build a form with correctly associated labels, named controls, and a submit button
    • Explain how GET and POST place submitted values in an HTTP request
    • Explain why POST alone does not encrypt or secure form data
  • Lesson 2 — Input Types and Attributes· 18 min· ~129 MB

    The many input types — email, password, number, date, checkbox, radio, file — and the attributes that make them behave.

    • Choose the right input type for a given piece of data
    • Use required, placeholder, and value attributes
    • Explain how input type improves the mobile keyboard and built-in validation
  • Lesson 3 — Labels and Form Accessibility· 45 min· ~326 MB

    Why every input needs a real label — and how fieldset and legend group related fields for screen reader users.

    • Associate a <label> with an input using for and id
    • Explain why a placeholder is not a substitute for a label
    • Group related inputs with <fieldset> and <legend>
  • Lesson 4 — Tables in HTML· 36 min· ~263 MB

    Build a real data table with rows, cells, and headers — and know when a table is genuinely the right tool.

    • Build a table with <table>, <tr>, <td>, and <th>
    • Use <thead> and <tbody> to structure a table
    • Explain why tables should not be used for page layout
  • Lesson 5 — Semantic HTML Elements· 25 min· ~177 MB

    header, nav, main, article, section, footer — elements that describe what a region of the page IS, not just how it looks.

    • Use header, nav, main, article, section, and footer appropriately
    • Explain the difference between a <div> and a semantic element
    • Describe how semantic structure helps screen readers and search engines
  • Lesson 6 — Validating Your HTML· 20 min· ~147 MB

    Catch broken markup before it causes mysterious bugs, using the official W3C validator.

    • Run a page through the W3C validator
    • Read a validator error and locate it in your code
    • Explain why invalid HTML can cause unpredictable rendering

Level 3 — CSS: Layout and Responsive Design

Style accessible interfaces and build layouts that adapt across phones, tablets, and desktop screens.

Module 7 — CSS Fundamentals

  • Lesson 1 — Connecting CSS to HTML· 11h 8m· ~4810 MB

    The three ways to attach styles to a page, why external stylesheets win, and the basic selector-property-value syntax.

    • Link an external stylesheet with the <link> tag
    • Write a CSS rule using selector, property, and value
    • Explain why external stylesheets are preferred over inline styles
  • Lesson 2 — CSS Selectors· 11h 8m· ~4810 MB

    Target exactly the elements you mean — by element, class, id, or by where they sit inside another element.

    • Select elements by tag, class, and id
    • Explain when to use a class versus an id
    • Combine selectors to target nested elements
  • Lesson 3 — Why Your CSS Isn't Working: Cascade, Specificity and Inheritance· 29 min· ~209 MB

    The single most common beginner frustration, explained properly — plus a tour of the other concepts that trip people up.

    • Explain how the browser chooses between conflicting rules
    • Rank the specificity of element, class, and id selectors
    • Describe which properties are inherited by child elements
  • Lesson 4 — Colours, Units and Values· 11h 8m· ~4810 MB

    Naming colours in hex, rgb and hsl, and knowing when to reach for px, rem, em, or a percentage.

    • Write colours as named values, hex, rgb, and hsl
    • Explain the difference between px, rem, em, and %
    • Choose an appropriate unit for font sizes and spacing
  • Lesson 5 — The Box Model· 11h 8m· ~4810 MB

    Every element is a box — content, padding, border, margin — and the one property that makes sizing behave the way you expect.

    • Identify content, padding, border, and margin on an element
    • Explain how box-sizing: border-box changes width calculation
    • Inspect an element's box model in DevTools
  • Lesson 6 — Styling Text with CSS· 27 min· ~191 MB

    Making text readable — families, sizes, weight, line height, alignment, and the transform and decoration properties.

    • Set font-family with a sensible fallback stack
    • Use font-size, font-weight, and line-height to improve readability
    • Apply text-align, text-transform, and text-decoration

Module 8 — Layout with Flexbox and Grid

  • Lesson 1 — The Display Property: Block, Inline and Inline-Block· 6h 31m· ~2817 MB

    Why a div takes up a whole line and a span doesn't — and the first tool for putting two boxes side by side.

    • Explain the difference between block, inline, and inline-block elements
    • Use display: inline-block to place boxes side by side
    • Fix the alignment gap that appears between inline-block elements
  • Lesson 2 — Flexbox: The Basics· 34 min· ~245 MB

    One declaration turns a container into a flexible row — then you control alignment along both axes.

    • Turn a container into a flex container with display: flex
    • Control layout along the main axis with justify-content
    • Align items across the cross axis with align-items
  • Lesson 3 — Flexbox Layout Patterns· 16 min· ~112 MB

    Four patterns you will reach for constantly — even columns, wrapping card rows, content with a sidebar, and pushing items apart.

    • Build even columns and a wrapping card row with flex
    • Create a content-plus-sidebar layout
    • Push an element to the far side using auto margins
  • Lesson 4 — CSS Grid: The Basics· 37 min· ~267 MB

    Two-dimensional layout — define columns, place items on the grid, and use the browser's grid inspector.

    • Create a grid with display: grid and grid-template-columns
    • Space a grid with the gap property
    • Span an item across multiple columns using line numbers
  • Lesson 5 — Building a Responsive Card Grid· 32 min· ~229 MB

    A full build — a card grid that reflows itself as the screen changes, without a single media query.

    • Use auto-fit with minmax() to make a grid respond without media queries
    • Control image shape with aspect-ratio and object-fit
    • Make one card span wider as a featured item
  • Lesson 6 — CSS Position: Static, Relative, Absolute and Fixed· 9 min· ~68 MB

    Take an element out of the normal flow and put it exactly where you want it.

    • Distinguish static, relative, absolute, and fixed positioning
    • Offset an element with top, right, bottom, and left
    • Explain what an absolutely positioned element is positioned relative to
  • Lesson 7 — Positioning in the Real World· 22 min· ~155 MB

    Containing blocks, sticky headers, and why position: fixed sometimes mysteriously stops working.

    • Explain what a containing block is and how it governs absolute positioning
    • Build a sticky element with position: sticky
    • Identify what can break position: fixed

Module 9 — Responsive Design and Polish

  • Lesson 1 — Adding Your First Breakpoint· 7 min· ~53 MB

    Take a fixed layout and make it adapt — the practical introduction to media queries.

    • Write a media query with a breakpoint
    • Change a layout at a given screen width
    • Test a layout at different widths using DevTools
  • Lesson 2 — Mobile-First Design and Choosing Breakpoints· 27 min· ~195 MB

    Why you write the small-screen styles first and layer up — and how to pick breakpoints that aren't arbitrary.

    • Explain what mobile-first means and why it produces simpler CSS
    • Choose breakpoints based on where the layout breaks
    • Use min-width queries to layer on larger-screen styles
  • Lesson 3 — Fluid Sizing with min(), max() and clamp()· 18 min· ~131 MB

    Sizes that scale smoothly with the screen instead of jumping at breakpoints.

    • Use min() and max() to set a fluid size with a limit
    • Use clamp() for a size with a minimum, preferred, and maximum
    • Explain why fluid type reduces the need for breakpoints
  • Lesson 4 — Responsive Images· 6 min· ~44 MB

    Stop images overflowing their container and blowing out your layout on a phone.

    • Prevent an image overflowing with max-width: 100%
    • Explain why a fixed image width breaks a mobile layout
    • Control how an image fills its space
  • Lesson 5 — Transitions and Timing· 18 min· ~130 MB

    Smooth state changes instead of abrupt jumps — and which properties are cheap to animate.

    • Apply transitions with a property, duration, timing function, and optional delay
    • Write transition shorthand for specific properties
    • Explain why opacity and transform are generally preferred for smooth UI motion
  • Lesson 6 — CSS Custom Properties· 16 min· ~117 MB

    Define a value once, reuse it everywhere — and scope your variables properly instead of dumping them all at the top.

    • Declare a custom property and use it with var()
    • Explain the benefit of defining a value in one place
    • Scope a custom property to a component rather than :root
  • Lesson 7 — Debugging CSS in Browser DevTools· 5 min· ~38 MB

    Stop guessing at why a style isn't applying — inspect it, edit it live, and see what the browser actually did.

    • Inspect an element and read its applied styles
    • Edit CSS live in the browser to test a fix
    • Find why a rule isn't applying by reading overridden styles

Level 4 — JavaScript and Real Projects

Add behaviour, work with data and browser events, validate interactions, test, and publish a complete project.

Module 10 — JavaScript Basics

  • Lesson 1 — What JavaScript Is and Adding It to a Page· 7h 55m· ~3417 MB

    The third language of the web — what it adds on top of HTML and CSS, and how to attach it to a page.

    • Explain how JavaScript adds behaviour to an HTML page
    • Link an external JavaScript file using a script element
    • Choose a safe loading strategy such as defer and inspect console output
  • Lesson 2 — Variables: let, const and var· 22h 16m· ~9619 MB

    Store a value under a name so you can use it, change it, and reason about it.

    • Declare a variable with let and const
    • Explain why const should be your default
    • Recognise var in older code and know how it differs
  • Lesson 3 — Strings, typeof and Data Types· 22h 16m· ~9619 MB

    Working with text — joining it, embedding values in it — and checking what type a value actually is.

    • Join strings with concatenation and template literals
    • Use typeof to check a value's type
    • Name JavaScript's basic data types including null and undefined
  • Lesson 4 — Numbers and Math· 7h 55m· ~3417 MB

    Arithmetic, operator precedence, and the built-in Math methods you'll actually reach for.

    • Use arithmetic and assignment operators including modulus
    • Explain operator precedence in an expression
    • Apply Math methods such as round, floor, and random
  • Lesson 5 — Getting Input from the User· 7h 55m· ~3417 MB

    Take a value from a person and use it — the quick way and the real way.

    • Collect input with prompt for quick experiments
    • Read a value from an HTML input element
    • Convert text input into a number before doing arithmetic
  • Lesson 6 — Building Your First Program· 7h 55m· ~3417 MB

    Put variables, input, and output together into something small that actually works.

    • Combine variables, input, and output into a working program
    • Break a small problem into ordered steps
    • Debug a program using console.log

Module 11 — Control Flow and Functions

  • Lesson 1 — Making Decisions: if, else if, else· 7h 55m· ~3417 MB

    Run one block of code or another depending on what's true.

    • Write an if statement that runs code conditionally
    • Chain conditions with else if and else
    • Explain what a condition evaluates to
  • Lesson 2 — Comparison and Logical Operators· 22h 16m· ~9619 MB

    The operators that build conditions — and the equality trap that catches every beginner.

    • Compare values with ===, !==, >, <, >= and <=
    • Combine conditions with && and || and negate with !
    • Explain what truthy and falsy mean
  • Lesson 3 — Loops: for, while and do...while· 7h 55m· ~3417 MB

    Repeat work without repeating yourself — and know how to stop.

    • Write a for loop with a counter
    • Use a while loop when the number of repeats isn't known upfront
    • Explain what causes an infinite loop and how to avoid it
  • Lesson 4 — Functions· 7h 55m· ~3417 MB

    Package a piece of logic once, give it a name, and use it everywhere.

    • Declare a function and call it
    • Pass values in as parameters
    • Return a value out of a function and use it
  • Lesson 5 — Scope: var, let and const· 7h 55m· ~3417 MB

    Where a variable is visible, and why the modern keywords behave better than the old one.

    • Explain what scope means for a variable
    • Describe how var, let, and const differ
    • Choose the right declaration keyword by default
  • Lesson 6 — Arrow Functions· 10 min· ~69 MB

    The shorter function syntax you'll see everywhere in modern JavaScript.

    • Write a function using arrow syntax
    • Use an implicit return for a single-expression function
    • Recognise arrow functions when reading other people's code
  • Lesson 7 — Switch Statements and the Ternary Operator· 7h 55m· ~3417 MB

    Two cleaner alternatives to a long chain of if/else.

    • Write a switch statement with cases and a default
    • Explain why break matters in a switch
    • Write a conditional assignment with the ternary operator

Module 12 — Arrays, Objects and Working with Data

  • Lesson 1 — Arrays· 22h 16m· ~9619 MB

    Store a list of values in one variable — indexing, length, and adding or removing items.

    • Create an array and read values by index
    • Use .length to find how many items an array holds
    • Add and remove items with push and splice
  • Lesson 2 — Looping Through Arrays: for and forEach· 22h 16m· ~9619 MB

    Do something to every item in a list without writing the same line ten times.

    • Loop over an array with an index-based for loop
    • Use forEach to run a function on every item
    • Build a new array from inside a loop
  • Lesson 3 — Transforming Arrays: map and filter· 22h 16m· ~9619 MB

    Two methods that replace most of the loops you would otherwise write.

    • Use map to build a new array by transforming every item
    • Use filter to build a new array of items that pass a test
    • Write these with arrow function shorthand
  • Lesson 4 — Objects· 22h 16m· ~9619 MB

    Group related information about one thing — a learner, a product, an order — under named properties.

    • Create an object with named properties and read them with dot notation
    • Use bracket notation and explain when it's necessary
    • Store a function on an object as a method
  • Lesson 5 — Arrays of Objects· 22h 16m· ~9619 MB

    The shape almost every real application's data takes — a list of records — and how to work through it.

    • Build an array of objects representing a list of records
    • Loop over it and read properties from each item
    • Add and remove records from the list
  • Lesson 6 — JSON and Destructuring· 22h 16m· ~9619 MB

    The universal format for moving data between systems, and a shorter way to pull values out of objects and arrays.

    • Explain what JSON is and why systems exchange data in it
    • Convert between objects and JSON with stringify and parse
    • Destructure values out of an object and an array

Module 13 — DOM, Events and Interactive Interfaces

  • Lesson 1 — Understand the DOM Tree

    Learn how a browser represents HTML as a tree that JavaScript can inspect and update.

    • Explain the relationship between HTML and the DOM
    • Select elements using common DOM methods
    • Update text or classes without rebuilding the page
  • Lesson 2 — Handle Events and User Actions

    Respond to clicks, input, and form submission without making interfaces confusing.

    • Register event listeners on appropriate elements
    • Explain event objects and preventDefault in forms
    • Give interactive controls clear accessible names and states
  • Lesson 3 — Validate Forms and Show Useful Feedback

    Check user input and communicate errors clearly before processing a form.

    • Use built-in HTML constraints such as required and type
    • Add JavaScript checks for rules beyond basic HTML constraints
    • Explain why client-side validation is not a security boundary
  • Lesson 4 — Build Accessible Interactive Components

    Make menus, tabs, and controls usable with keyboard and assistive technology.

    • Use semantic buttons and links for their intended roles
    • Support keyboard focus and understandable state changes
    • Avoid interaction patterns that depend only on hover or colour

Module 14 — Testing, APIs and Deployment

  • Lesson 1 — Understand Fetch and Asynchronous Results

    Request data from an API and handle success, failure, and loading states.

    • Explain why fetch returns a promise
    • Check response status before parsing JSON
    • Show loading, empty, success, and error states
  • Lesson 2 — Test a Website Before Release

    Use a repeatable checklist to catch layout, interaction, and console errors.

    • Test core tasks with valid, empty, and invalid inputs
    • Inspect console and network errors in developer tools
    • Check keyboard operation and common viewport sizes
  • Lesson 3 — Deploy and Verify a Live Website

    Publish a project and confirm that the live version works outside your editor.

    • Choose a hosting method appropriate to a static site or backend app
    • Check build output, asset paths, and environment configuration
    • Verify the live URL and keep a rollback copy
  • Lesson 4 — Prepare a Portfolio-Ready Project

    Present the problem, design decisions, working result, and limitations honestly.

    • Define the intended user and problem the capstone website solves
    • Deliver a responsive, semantic, accessible site with a working JavaScript interaction
    • Test and publish the site, then document evidence, decisions, and limitations

Spin for a discount

One spin, one discount on this Learning Path.

10% OFF10% OFF10% OFF10% OFF10% OFF10% OFF10% OFF10% OFF
Get Full Access — KSh 500

Reviews

No reviews yet.