App coding course

Lesson 1 • Reading and Writing Code Effectively

Teaches code readability, commenting, and naming conventions. Connects clean code habits to long-term maintainability.

Lesson 2 • Understanding Apps and Platforms

Defines native, hybrid, and web apps and their trade-offs. Establishes platform vocabulary used throughout the course.

Lesson 3 • Setting Up Your Dev Environment

Installs and configures the tools needed to write and run code. Removes setup friction before any coding begins.

Lesson 1 • Anatomy of a Screen Layout

Breaks down screens into containers, rows, columns, and components. Provides the structural vocabulary for all layout work ahead.

Lesson 2 • Navigation Patterns and Screen Flow

Implements stack, tab, and drawer navigation to connect multiple screens. Reinforces layout skills by building a multi-screen prototype.

Lesson 3 • Styling with CSS and Style Sheets

Applies colour, typography, and spacing through style declarations. Connects visual design decisions to code properties.

Lesson 4 • Responsive and Adaptive Layouts

Adjusts layouts for multiple screen sizes using breakpoints and flexible units. Ensures apps look correct on phones and tablets.

Lesson 1 • Managing Local State in Components

Uses built-in state hooks to track and update component-level data. Covers counters, toggles, and form inputs as practical examples.

Lesson 2 • Global State with Context and Stores

Implements a context provider or lightweight store to share state app-wide. Eliminates prop drilling for cross-cutting concerns.

Lesson 3 • What Is State and Why It Matters

Defines local vs. global state and explains when each is appropriate. Grounds abstract state concepts in visible UI behaviour.

Lesson 4 • Lifting State and Sharing Data

Moves state up the component tree to share data across siblings. Introduces prop drilling and its limitations.

Lesson 1 • Authentication Flows

Implements login, token storage, and protected routes using standard auth patterns. Secures data access without exposing credentials.

Lesson 2 • REST API Fundamentals

Explains HTTP methods, status codes, and JSON payloads. Provides the vocabulary needed to consume any REST endpoint.

Lesson 3 • Fetching Data in the App

Implements fetch and async/await to retrieve data and render it. Ties API responses directly to component state.

Lesson 4 • Sending Data to a Server

Builds forms that POST user input to an API and handle responses. Covers validation before submission and server error feedback.

Lesson 1 • Building a CRUD Feature End to End

Creates a full create-read-update-delete feature wiring UI to API. Demonstrates how all prior skills integrate into one cohesive flow.

Lesson 2 • Reusable Component Libraries

Extracts repeated UI patterns into shared components with configurable props. Speeds up feature development and enforces visual consistency.

Lesson 3 • Error Boundaries and Fallback UI

Catches runtime errors at the component level and displays graceful fallbacks. Prevents a single bug from crashing the entire app.

Lesson 4 • Feature Flags and Conditional Features

Toggles features on or off at runtime without redeploying code. Enables safe rollouts and A/B testing of new functionality.

Lesson 1 • End-to-End Testing on Device

Automates full user journeys on a real or simulated device. Provides the highest confidence that the app works as shipped.

Lesson 2 • Integration Testing User Flows

Tests multiple components working together to simulate real user interactions. Catches bugs that unit tests miss at component boundaries.

Lesson 3 • Debugging Techniques and Tools

Uses console logs, breakpoints, and dev-tool inspectors to locate bugs. Builds a repeatable debugging workflow applicable to any error type.

Lesson 4 • Test Coverage and Quality Metrics

Measures how much code is exercised by tests and identifies gaps. Connects coverage data to release confidence decisions.

Lesson 1 • Network and API Performance

Reduces API call frequency and payload size through caching and batching. Improves perceived speed on slow or unreliable connections.

Lesson 2 • App Startup and Bundle Size

Shrinks initial load time by splitting code and deferring non-critical assets. Targets the first meaningful paint as the key metric.

Lesson 3 • Image and Asset Optimisation

Compresses, resizes, and lazy-loads images to reduce load time and memory. Covers format selection for quality-to-size trade-offs.

Lesson 4 • Optimising Renders and Re-renders

Prevents unnecessary component re-renders using memoisation and pure components. Directly improves UI responsiveness under heavy state changes.

Lesson 1 • Submitting to App Stores

Walks through store listing creation, metadata, screenshots, and review submission. Covers common rejection reasons and how to avoid them.

Lesson 2 • Build Configuration and Environments

Separates development, staging, and production configs to prevent environment bleed. Ensures the correct API endpoints and keys ship with each build.

Lesson 3 • Post-Release Monitoring and Crash Reporting

Integrates crash reporting and analytics to detect issues after launch. Closes the feedback loop between users and the development team.

Lesson 4 • Code Signing and App Packaging

Signs the app binary with certificates to satisfy platform security requirements. Produces a distributable package ready for store submission.