Beyond the basics
This handbook has covered the fundamentals: setting a project up, components, JSX, styling, props, state, events, forms, effects, and the hooks that tie them together, along with the process of thinking in React to turn a design into a working app and the work of keeping that app accessible. That's the core of the library, and it's enough to build real, working interfaces. A handful of concerns sit outside that core, and nearly every production React app reaches for some combination of them sooner or later. This chapter is the map: what each one is for, where it fits, and where to go learn it.
Routing
A single-page app renders everything in the browser and swaps out what's on screen instead of asking the server for a fresh page each time. That's part of what makes it feel fast, but it also means the browser's usual navigation, typing a URL, clicking back, bookmarking a page, has nothing to hook into unless something builds it. Routing is that piece: it maps a URL to the view that should show, keeps the address bar in sync as the user moves around, and keeps the back button working, all without a full page reload. React Router is the library most React apps reach for to handle this.
Meta-frameworks
React itself only renders the interface. It doesn't ship an opinion on routing, how to load data before a page appears, or how to render a page on a server before it reaches the browser, three things almost every production app needs. A meta-framework is a framework built on top of React that supplies those missing pieces, and Next.js is the one most of the React world reaches for. That's why most production React apps aren't React on its own: they're React running inside Next.js or something like it. The kinds of frameworks covers meta-frameworks in more depth, including how Next.js relates to React.
Tooling
This piece already has a chapter of its own. Setting up a React project covered why the JSX used throughout this handbook isn't valid JavaScript by itself, and how Vite runs a dev server, compiles JSX on the fly, and bundles everything into optimized files when it's time to ship. It belongs on this map because it sits underneath every other item here: a router, a meta-framework, and a deploy step all assume a build tool is already doing that job. Go back to the setup chapter when you want the mechanics again.
Deployment
Once the app is built, it needs a home. Running a build command, vite build for a Vite project, produces a folder of plain HTML, CSS, and JavaScript files: the static output of the app. Shipping that folder to a host, such as Netlify, Vercel, or Cloudflare Pages, is what puts the app on the internet for other people to use.
Where this leaves you
That's the map: routing to move between views, a meta-framework like Next.js to handle what React leaves out, the Vite build from the setup chapter turning the code into files a browser can load, and a host to put the result online. None of it needs to be learned today. Choosing and learning a framework is the guide for deciding whether and when to add a piece like Next.js, and how to weigh the options once that time comes. The fastest way through all of it is the same approach that got you this far: build one small real project. Pick something worth making, lean on the fundamentals from this handbook, and bring in the pieces above only once the project actually asks for them.
