AI Full Stack Engineer

Four parts

What you learn

Four parts. Each one ends with something you have built. Open a part to see every phase and lesson.

1. 1

   Frontend taught with React

   Everything a user sees and clicks. You write HTML, CSS and JavaScript by hand before React gets involved, then build typed, routed apps that stay fast and work from the keyboard.

   • How a web page is built: HTML, CSS, layout, and putting a site online.
   • JavaScript: the language, working with data, and fetching from a server.
   • React: components, state, forms, and where each piece of state belongs.
   • TypeScript, routing, a real API, then tests, accessibility and deploying.

   You build a hand-made landing page, a plain JavaScript data app, and a typed React dashboard with tests.

   Phase by phase

   Tools: React, TypeScript, Vite, Tailwind CSS, React Router, TanStack Query, Vitest, Playwright.

   1. The Browser

      Build and style a real page before any framework hides how it works.

      How a page arrives · Semantic HTML and forms · The cascade and box model · Layout, Git and your first deploy

      At the end: a responsive, keyboard-navigable site deployed to a real URL.

   2. JavaScript

      Make a page respond to a person with no framework doing it for you.

      The language first · Arrays and objects · DOM and events · Async and fetch · Modules, npm and Vite

      At the end: a plain JavaScript app that fetches live data and handles loading, empty and error states.

   3. Thinking in React

      Move from pages to components and put each piece of state in the right place.

      Components, props, JSX · Lists and keys · State and events · Lifting state and composition · Forms

      At the end: an interactive multi-component React app with no behaviour you can't explain.

   4. Types, Data, Routes

      Talk to a real API without hand-rolled fetching, and let the types catch the rest.

      TypeScript where it pays · Routing with React Router · Server state with TanStack Query · Suspense and error boundaries · Client state, sparingly

      At the end: a typed, routed React app running against a real API with honest loading and error UI.

   5. Ship It

      Get an app off your machine and prove it holds up for someone who isn't you.

      Tests you'll actually run · The accessibility audit · Performance you can measure · Build, deploy, hand over

      At the end: a deployed app with a passing test suite, an accessibility audit and a measured performance budget.

2. 2

   Backend taught with Node.js

   APIs, databases, authentication and the servers that answer them. You build services that hold real data, survive real traffic, and fail in ways you can explain.

   • Running and debugging JavaScript on your own machine with Node.js.
   • HTTP from the ground up, then a JSON API with Express and validation.
   • SQL by hand, then PostgreSQL with migrations and tests.
   • Logins, sessions, permissions, common attacks, and deploying with Docker.

   You build a bare HTTP server, a library catalog API with a real database, and a login system you can defend.

   Phase by phase

   Tools: Node.js, TypeScript, Express, PostgreSQL, Drizzle ORM, Zod, node:test, Docker.

   1. The Runtime

      Write, run and debug JavaScript on your own machine instead of in a browser.

      JavaScript, server side · Modules, npm and node_modules · Async without fear · When it breaks · The built-in toolbox

      At the end: a command-line tool that reads files, calls a public API and writes a report.

   2. HTTP and Your First API

      Turn incoming requests into a JSON API a stranger could use without asking you.

      HTTP, unabstracted · Express 5 · Designing endpoints · Never trust the body (validation with Zod) · Types without a build step

      At the end: a CRUD API with validated input, honest status codes and one error handler.

   3. Data That Survives a Restart

      Put real, related data behind the API and keep it correct while the schema changes.

      SQL before any ORM · Relationships and constraints · Postgres from Node · Migrations and transactions · Tests you can trust

      At the end: a Postgres-backed API with migrations, seed data and tests that run on a throwaway database.

   4. Users, Trust and Production

      Let real people log in without handing them each other's data, then run it somewhere real.

      Authentication · Authorization · Attacks you'll actually meet · Your dependencies run your code · Ship it and watch it

      At the end: a deployed, containerised API with sessions, ownership checks, structured logs and a health check.

3. 3

   Databases taught with PostgreSQL

   SQL, schema design, transactions and the query planner. You write queries that are correct before they are fast, then make them fast by understanding what Postgres is actually doing.

   • Correct queries: SELECT, joins, grouping, NULL, and subqueries.
   • Designing tables so wrong data cannot be stored, with migrations.
   • How Postgres works inside: transactions, isolation, locks, vacuum.
   • Indexes and query plans, then backups, replication and restore.

   You build a clean schema from a messy spreadsheet, one slow query made ten times faster, and a break-and-restore drill.

   Phase by phase

   Tools: PostgreSQL, psql, DBeaver, Docker, Flyway, pgbench, pg_stat_statements, pgvector.

   1. Getting Correct Answers

      Get a correct answer out of a database you did not design.

      The relational model · Your first queries · Joins · Duplicates, grouping and aggregates · NULL is not a value · Subqueries and EXISTS

      At the end: a report answering 20 questions about a real dataset, with every row count justified.

   2. Designing a Schema

      Design tables where the wrong data cannot be stored in the first place.

      From requirements to tables · Normalization · Choosing types · Keys and constraints · Migrations

      At the end: a schema built by versioned migrations that rejects bad rows on insert.

   3. How Postgres Works

      Explain what Postgres does between BEGIN and the bytes on disk.

      Pages, heaps and TOAST · Transactions and isolation · Locks and deadlocks · MVCC and vacuum

      At the end: a concurrency problem reproduced in two sessions, plus the isolation level that stops it.

   4. Making Queries Fast

      Explain why a query is slow before adding an index.

      How an index works · Reading a query plan · Indexing strategy · Statistics and tuning

      At the end: one slow query made ten times faster, with the plans from before and after.

   5. Running It For Real

      Keep the database available through failure, growth and your own mistakes.

      Backup and recovery · Replication and failover · Partitioning and upgrades · Postgres beyond relational (jsonb, full-text, pgvector)

      At the end: a replicated cluster restored to a chosen point in time after you break it on purpose.

4. 4

   DevOps & Cloud taught with Docker

   Linux, containers, Kubernetes and the pipelines between them. You install an app by hand first, containerise those exact steps, run it on a cluster, and ship changes without downtime.

   • The Linux shell, processes, ports, logs, and installing an app by hand.
   • Docker: images, Dockerfiles, volumes, and Compose for a whole app.
   • CI with GitHub Actions, registries, scanning and signing images.
   • Kubernetes with GitOps, then cloud infrastructure as code and monitoring.

   You build an app that starts with one command, a pipeline that publishes an image, and a cluster you can wipe and rebuild from Git.

   Phase by phase

   Tools: Docker, Docker Compose, Git and GitHub Actions, GitHub Container Registry, Kubernetes (k3d), Argo CD, OpenTofu, OpenTelemetry, Grafana.

   1. Before Containers

      Understand the machine an app runs on by running one the hard way first.

      The shell and the filesystem · Processes, ports and logs · Install it by hand

      At the end: a web app and database installed by hand on a Linux server, with notes for every command.

   2. Containers

      Turn a manual install into an image that runs identically on any machine.

      Images are not containers · Your first Dockerfile · Layers, cache and size · Where the data goes · Compose for the whole app

      At the end: a multi-container app a stranger can start with one command.

   3. Ship It

      Make every merge produce an image you can trust and run anywhere.

      Registries, tags and digests · Builds for any CPU · CI with GitHub Actions · What is actually in your image

      At the end: a repository whose main branch publishes a scanned, signed image automatically.

   4. Clusters

      Run your images across several machines and deploy by merging instead of typing.

      Kubernetes without a cloud bill · Reading a broken pod · Config, secrets and storage · Getting traffic in · GitOps with Argo CD

      At the end: a local Kubernetes cluster whose entire state comes from a Git repository.

   5. Cloud and Operations

      Create real cloud infrastructure from code, know when it breaks, and delete it before it costs you.

      Infrastructure as code · The bill is not a cap · Knowing when it breaks

      At the end: a cloud environment defined in code with one dashboard, one alert, a short runbook and a teardown you have run.