You know JavaScript. Now work with it as a full-stack developer.

How a React application is put together from the inside.

You learn how React thinks: the interface as components, data flowing down, and the screen changing because the state changed — not because you reached into the DOM.

An interface built from components that talk to each other, not one large file.

From one page to a whole application.

Adding pages and routes, and handling input properly: validation before submitting, error messages a person can understand, and a layout that works on a phone as well as a desktop.

A multi-page application whose forms check their input before sending it.

What changes when the interface starts talking to a server.

Connecting React to a real API: fetching data, handling the wait, and behaving correctly when a request fails — the cases that separate a demo from a real application.

An interface that reads its data from an API and behaves correctly while loading and when it fails.

Who is signed in, and what are they allowed to see?

A complete sign-in experience on the frontend: the session, protected pages, and hiding what a user should not see based on their role.

A real sign-in, protected pages, and an interface that changes with the role of the person signed in.

The first backend you build yourself.

How Node works, and building an Express server that is organised — routes, controllers and middleware — rather than one file holding everything.

An organised Express server answering real requests.

An API someone else can actually use.

Building APIs the way they are expected to behave: clear routes, correct status codes, validated input and errors that explain themselves — tested in Postman before any interface sees them.

A documented set of APIs, tested in Postman and ready for React to consume.

Designing a database, not just insert and find.

Designing data for a real project: what deserves its own document, what belongs inside another, and how to relate the two — a difference that only shows once the data grows.

A database designed for a real project and wired to the APIs.

Security is not a step at the end.

Building a secure user system on the backend, and learning the common weaknesses well enough to close them at the start rather than after something happens.

A backend with secure sign-in, roles, and protection against the common weaknesses.

From a requirement to the first working feature.

Nobody says "build a shop" — we start from requirements the way a client project does, split it into modules and tasks, and design the database before the first line of code.

The shop foundation works end to end: products, categories, search and filters from the interface to the database.

When the shop can actually take an order.

Completing the buying journey from cart to order, and building the admin panel that manages products, orders, stock and permissions.

A complete shop: a customer site, an admin panel, and the APIs behind both.

A second project of an entirely different shape.

A CMS is not a shop — the business logic differs, and the weight here falls on architecture, code quality and permissions, so you learn to handle more than one kind of project.

A complete CMS with an admin panel, a public site and publishing permissions.

The project does not stay on localhost:3000.

The last week mirrors a handover: code review, testing, deploying the frontend, the backend and the database, and preparing a portfolio and a presentation you could give in an interview.

Two projects live on the internet, a ready portfolio, and a presentation you can give in an interview.