How I'd Learn to Build Apps and Websites in 2026 (The Roadmap I Actually Used)

I get asked the same question a lot: "I want to build apps and websites — where do I start?" I first wrote this roadmap in 2022 after teaching myself the stack and using it to ship production apps. I've rewritten it from scratch for 2026, because half of what I'd recommend has changed and the other half I'd now teach in a completely different order.

This isn't a link dump. It's the sequence I'd follow if I were starting over today, plus the mistakes that cost me the most time so you can skip them.

The one rule that matters more than the stack

Learn one thing at a time, and finish before you move on. The single biggest reason people stall isn't difficulty — it's jumping ahead. They start React before they're comfortable with JavaScript, hit a wall that's actually a JS gap, and conclude they're "bad at React." You're not. You skipped a step.

So the order below is strict. Don't open the next section until you can build something small in the current one without copying.

And ship everything in public. Every project goes on GitHub and gets a short post on LinkedIn or X. I cannot overstate how many opportunities came to me from publicly visible half-finished projects rather than a polished private portfolio. Visible beats perfect.

Step 1 — The fundamentals (HTML, CSS, JavaScript, Git)

Before any framework, you need to be dangerous with the raw materials of the web.

HTML & CSS — enough to lay out a responsive page by hand. Learn flexbox and grid properly; almost every layout reduces to those two.
JavaScript — this is where to spend real time. Arrays, objects, functions, promises, async/await, and how the DOM works. Frameworks are abstractions over JS — the better your JS, the less mysterious React feels later.
Git & the command line — branch, commit, push, open a pull request. You'll use this every single day for the rest of your career.

Build, don't just watch. Aim for ~10 small static projects: a landing page, a calculator, a to-do list, a clone of a site you like. Deploy each one (Vercel or GitHub Pages — free, takes minutes). A deployed mediocre project teaches you more than a tutorial you only watched.

The trap here is "tutorial hell" — endlessly consuming courses without building. The cure is to close the video and rebuild the thing from memory. The gaps you hit are exactly what you need to learn next.

Step 2 — Modern JavaScript (ES6+)

A short but essential stop. Arrow functions, destructuring, spread/rest, template literals, modules, optional chaining. This is the dialect React is written in, and it's maybe a day of focused study. Skipping it is why so much React code looks like hieroglyphics to beginners.

Step 3 — React (the web)

Now the fun part. React is still the default for new web work in 2026, and learning it unlocks most of the front-end job market.

Focus on the mental model, not the syntax:

Components & props — UI as composable functions.
State & the useState/useEffect hooks — how data changes drive re-renders.
Lists, conditional rendering, and forms — the bread and butter of every app.
Data fetching — talking to an API and rendering the result.

For anything real, don't reach for plain React — start with Next.js. It gives you routing, server rendering, and a deployment story out of the box, and it's what I use for nearly every web project (including this site). Learning React through Next.js saves you from re-learning everything once you outgrow a toy app.

Build two non-trivial projects: an e-commerce-style storefront (handles state, cart, routing) and a clone of an app you use daily. These are portfolio-grade and interview-ready.

Step 4 — React Native (mobile)

Here's the payoff for learning React first: React Native is the same model pointed at iOS and Android. Once React clicks, you can ship to the App Store and Play Store with most of your existing knowledge.

Use Expo. In 2022 the "should I use Expo?" debate was real; in 2026 it isn't — Expo is how you build React Native. It handles the native toolchain, over-the-air updates, and builds without you touching Xcode for most projects.

What's genuinely different from web:

Navigation — there's no URL bar; you learn a navigation library (Expo Router brings file-based routing that'll feel familiar from Next.js).
Native APIs — camera, notifications, storage, permissions.
Platform differences — iOS and Android disagree on small things, and you'll test on both.

I've shipped several apps to the stores this way — you can see a few on my projects page. The first one is the hardest; after that the loop gets fast.

Step 5 — The backend (when you're ready)

You can get surprisingly far with a managed backend before writing any server code. Firebase or Supabase give you auth, a database, and file storage with a client SDK — enough to build a real, multi-user product solo. Start there.

When you outgrow it, learn a proper backend: Node with a typed API, a real database (Postgres), and how authentication and deployment actually work. But don't front-load this. Build the front end of something real first — the backend questions you'll have then are concrete and worth answering, instead of abstract and forgettable.

What I'd do differently knowing what I know now

A few lessons from shipping this stack to real users that no roadmap told me up front:

TypeScript from day one. I resisted it early as "extra friction." It is the opposite — it's the cheapest bug prevention you'll ever buy, and every serious codebase uses it. Learn JS first, then never write plain JS again.
Deploy on day one, not at the end. A project that's live forces you to confront the unglamorous 20% — env vars, builds, broken images — that tutorials skip and real work is made of.
Read other people's code. Clone a well-built open-source repo and just read it. You'll absorb patterns no course teaches.
AI tools are leverage, not a replacement. In 2026 a coding assistant will scaffold and explain code for you — lean on it hard. But it amplifies what you understand and quietly multiplies what you don't. Build the fundamentals so you can tell good output from confident nonsense. (I wrote more on the AI tools I actually use.)

The whole thing in one line

Fundamentals → modern JS → React (via Next.js) → React Native (via Expo) → a backend when a real project demands one. One step at a time, everything deployed, everything in public.

That's the path. The stack will keep shifting — it always does — but the shape of "learn the fundamentals deeply, then build relentlessly in public" hasn't changed in a decade, and I don't expect it to. If you're starting today, the best time to ship your first ugly project was yesterday. The second best is this weekend.