Vibe Engines
YouTube

Vibe Engines is free, interactive AI engineering & system design — runs in your browser. Pick a learning path

Roadmap · 2026 Edition

Frontend
Engineer.

18 stations. 3 tracks. From HTML, CSS, and JavaScript to React, performance, and deployment — at your own pace.

Foundations
~5h 0/6
Core Frontend
~5h 0/6
Production
~6h 0/6
0 of 18 stations · ~0h of ~16h

The roadmap.

18 stations on 3 ladders, in order — each rung is written assuming the one above it. Mark them off as you go; your progress is saved in this browser.

0 / 18
Pick up at
Track 1 of 3

FoundationsStart here

6 rungs · ~5h · ends at Accessibility.

0/6 done
  1. HTML & Semantics

    Start here

    F1 · Beginner · 45 min

    The frontend starts with structure. Learn semantic HTML — the right element for the right job — because meaningful markup is what makes a page accessible, SEO-friendly, and easy to style. Divs everywhere is a smell; landmarks and headings are a map.

    • Semantic elements
    • Document structure
    • Forms & inputs
    • Metadata & SEO basics

    Build itRebuild a blog article page using only semantic tags — header, nav, main, article, aside, footer — no generic divs. Does the outline read clearly?

    ✓ CheckpointExplain what a screen reader gets from a semantic element that it does not get from a styled div.

  2. CSS Fundamentals

    F2 · Beginner · 60 min

    CSS is deceptively deep. Master the box model, the cascade and specificity, selectors, units (px/rem/em/%), and custom properties. Most "CSS is hard" pain is really specificity and the box model biting you — learn them once and the fog lifts.

    • Box model
    • Cascade & specificity
    • Selectors
    • Units & custom properties

    Build itStyle a card component. Deliberately create a specificity conflict, then resolve it — and swap a hard-coded color for a CSS custom property.

    ✓ CheckpointExplain a specificity conflict you have actually hit, and why reaching for !important made the next one worse.

  3. Layout: Flexbox & Grid

    F3 · Beginner · 60 min

    Layout is where CSS earns its keep. Flexbox handles one dimension (rows or columns); Grid handles two. Learn when to reach for each, plus responsive design with media queries and fluid units. This is the toolkit behind every modern page.

    • Flexbox (1D)
    • CSS Grid (2D)
    • Responsive & media queries
    • Fluid layouts

    Build itBuild a responsive dashboard: a Grid page shell with Flexbox toolbars inside, collapsing to one column on mobile. Which layouts are Grid, which Flex?

    ✓ CheckpointSay when grid beats flexbox and when it is the wrong reach, in terms of one dimension versus two.

  4. JavaScript

    F4 · Intermediate · 90 min

    JavaScript runs the web. Learn the core: types and coercion, functions and closures, the event loop and async (promises, async/await), array methods, and the ES modules that structure real apps. This is the language every framework is built on.

    • Types & closures
    • Event loop & async/await
    • Array & object methods
    • ES modules

    Build itWrite a debounce function from scratch, then use it on a search input. Explain why the closure captures the timer across calls.

    ✓ CheckpointExplain what the event loop does with an await, and why a long synchronous loop freezes the page while a slow fetch does not.

  5. The DOM & Events

    F5 · Intermediate · 55 min

    The DOM is the live tree the browser builds from your HTML, and JavaScript changes the page by mutating it. Learn selection, creation, event listeners, bubbling and delegation, and why touching the DOM in a loop is slow. Frameworks abstract this — but it is still underneath.

    • DOM tree & selection
    • Events & delegation
    • Bubbling / capturing
    • Reflow & repaint cost

    Build itBuild a to-do list with vanilla DOM APIs. Use one delegated listener on the parent instead of one per item — why is that faster?

    ✓ CheckpointExplain why event delegation exists, and what it saves you on a list that grows to a thousand rows.

  6. Accessibility

    F6 · Intermediate · 55 min

    A UI only works if everyone can use it. Learn keyboard navigation, focus management, ARIA (and when NOT to use it), color contrast, and screen-reader basics. Accessibility is not a checkbox at the end — it is a design constraint from the first line of markup.

    • Keyboard & focus
    • ARIA roles (sparingly)
    • Contrast & color
    • Screen-reader testing

    Build itMake a custom dropdown fully keyboard-operable and screen-reader announced. What ARIA does it need — and what does semantic HTML give free?

    ✓ CheckpointNavigate a page you built using only the keyboard. If you get stuck, you found the bug the mouse was hiding.

Track 2 of 3

Core FrontendThe craft

6 rungs · ~5h · ends at Testing.

0/6 done
  1. TypeScript

    T1 · Intermediate · 60 min

    TypeScript adds a type system on top of JavaScript, catching a whole class of bugs before runtime and making large codebases navigable. Learn types vs interfaces, generics, unions and narrowing, and how types document intent. It is the default for serious frontend today.

    • Types & interfaces
    • Generics
    • Unions & narrowing
    • Typing props & APIs

    Build itType a fetch wrapper that returns a typed result. Use a generic so the caller gets the right shape without casting.

    ✓ CheckpointExplain what narrowing is doing when TypeScript stops complaining after an if-check.

  2. React Fundamentals

    T2 · Intermediate · 75 min

    React is the dominant way to build UIs: describe what the UI should look like for a given state, and React reconciles the DOM. Learn components, JSX, props, state, the render cycle, and hooks (useState/useEffect) plus their rules. This is the heart of modern frontend.

    • Components & JSX
    • Props & state
    • Render cycle & reconciliation
    • Hooks & their rules

    Build itBuild a counter with useState and a data-loader with useEffect. Explain exactly what triggers a re-render — and what does not.

    ✓ CheckpointExplain why a component re-renders when its parent does, and what you would check before reaching for memoisation.

  3. State Management

    T3 · Advanced · 60 min

    As apps grow, state gets tangled. Learn the ladder: local state, lifting state up, context for cross-cutting values, and when a store (Redux, Zustand, signals) earns its place. The skill is keeping state as local as possible and reaching for globals last.

    • Local vs global state
    • Context & prop drilling
    • Stores (Redux/Zustand)
    • Derived state

    Build itA theme toggle needs to reach deep components. Solve it with context. When would you upgrade to a store instead?

    ✓ CheckpointPoint at a piece of state and justify why it is local rather than global. “It was easier” does not count.

  4. Data Fetching & Caching

    T4 · Advanced · 60 min

    UIs live on server data. Learn the request lifecycle in the browser (fetch, loading/error states, race conditions), then the modern answer: a data layer (React Query, SWR) that caches, dedupes, and revalidates. Server state is not UI state — treat it differently.

    • fetch & async UI states
    • Race conditions & abort
    • Caching & revalidation
    • Optimistic updates

    Build itFetch a list, then let the user favorite an item with an optimistic update that rolls back on error. How do you avoid a stale response overwriting a newer one?

    ✓ CheckpointDescribe the race condition where an older request resolves after a newer one, and how abort fixes it.

  5. Routing & Forms

    T5 · Intermediate · 55 min

    Two things every app needs. Client-side routing maps URLs to views without full reloads (and must handle deep links and history). Forms are deceptively hard: controlled inputs, validation, and accessible error handling. Get these right and the app feels solid.

    • Client-side routing
    • Nested routes & params
    • Controlled inputs
    • Validation & errors

    Build itBuild a multi-step form with URL-driven steps, so refresh and back-button keep the user in place. Where does the form state live?

    ✓ CheckpointExplain the difference between a controlled and an uncontrolled input, and which one makes validation straightforward.

  6. Testing

    T6 · Advanced · 55 min

    Untested UIs break silently. Learn the frontend test pyramid: unit tests for logic, component tests (Testing Library) that assert on what the user sees, and a few end-to-end flows (Playwright). Test behavior, not implementation — so tests survive refactors.

    • Unit vs component vs e2e
    • Testing Library
    • Mocking network
    • Testing behavior not internals

    Build itWrite a component test for a login form: assert the error shows on bad input, without asserting on internal state. Why is that more robust?

    ✓ CheckpointExplain why testing what the user sees survives a refactor that testing internals does not.

Track 3 of 3

ProductionShip & operate

6 rungs · ~6h · ends at Deployment & CI/CD.

0/6 done
  1. Build Tools & Bundlers

    P1 · Advanced · 55 min

    Modern frontend ships through a build step. Learn what a bundler (Vite, esbuild, webpack) actually does — module resolution, transpiling, tree-shaking, code-splitting — and why dev servers use native ESM for speed. The build is where your source becomes something a browser can load fast.

    • Bundling & module graph
    • Tree-shaking
    • Code-splitting
    • Dev server & HMR

    Build itA route is loaded by 5% of users. Code-split it so it is not in the main bundle. How do you measure the bytes you saved?

    ✓ CheckpointExplain what tree-shaking needs from your imports to work, and name an import style that silently defeats it.

  2. Rendering: CSR / SSR / SSG

    P2 · Advanced · 65 min

    Where does the HTML come from? Client-side rendering (ship JS, build in the browser), server-side rendering (HTML per request), static generation (HTML at build), and hydration that wires them up. Each trades off speed, SEO, and freshness — the defining architecture choice of a modern app.

    • CSR vs SSR vs SSG
    • Hydration
    • Streaming & RSC
    • SEO & first paint tradeoffs

    Build itA marketing page and a logged-in dashboard have opposite needs. Pick a rendering strategy for each and justify it by SEO and freshness.

    ✓ CheckpointExplain what hydration is actually doing, and why a slow hydrate can feel worse than no SSR at all.

  3. PWA & Offline

    P3 · Advanced · 50 min

    Progressive Web Apps make a site behave like a native app: installable, offline-capable, and resilient on flaky networks. Learn service workers (the programmable network proxy), caching strategies, and the manifest. Offline-first is a mindset, not just a feature.

    • Service workers
    • Caching strategies
    • Web app manifest
    • Offline-first UX

    Build itCache an app shell so it loads offline, but keep API data fresh when online. Which caching strategy for each — cache-first or network-first?

    ✓ CheckpointExplain what a service worker lets you serve when the network is gone, and what it cannot help with.

  4. Performance & Core Web Vitals

    P4 · Advanced · 65 min

    Speed is a feature. Learn the Core Web Vitals (LCP, INP, CLS), the critical rendering path, lazy-loading, image optimization, and how to profile with the browser devtools. Perception matters as much as milliseconds — measure real user experience, not just lab scores.

    • Core Web Vitals (LCP/INP/CLS)
    • Critical rendering path
    • Lazy-loading & images
    • Profiling & measuring

    Build itA page has a slow LCP and a layout shift. Diagnose both in devtools and fix them. Which metric does each fix move?

    ✓ CheckpointName which Core Web Vital your slowest page fails and what specifically causes it — LCP, INP and CLS have different culprits.

  5. Frontend Security

    P5 · Advanced · 50 min

    The browser is a hostile environment. Learn XSS (and why escaping and CSP matter), CSRF, secure token storage, CORS, and safe handling of user input. Frontend security is mostly about never trusting data — including data from your own API.

    • XSS & escaping / CSP
    • CSRF
    • Token storage
    • CORS & same-origin

    Build itYou must render user-authored HTML. Show how you prevent XSS — and why innerHTML with raw input is a trap.

    ✓ CheckpointExplain why escaping output defends against XSS while validating input alone does not.

  6. Deployment & CI/CD

    P6 · Advanced · 50 min

    Shipping frontend well: static hosting and CDNs, cache-busting with content hashes, preview deploys per pull request, and a CI pipeline that lints, tests, and builds before anything goes live. The goal is boring, reversible releases — deploy on every merge without fear.

    • CDN & static hosting
    • Cache-busting
    • Preview deploys
    • CI: lint / test / build

    Build itSet up a pipeline that gives every PR a preview URL and blocks merge on failing tests. How do content hashes let you cache assets forever?

    ✓ CheckpointExplain what cache-busting solves, and what breaks when a deploy ships an HTML file that references a purged asset.

The roadmap at a glance

All 18 rungs on one screen. Each track assumes the one before it; the highlighted rung is where a track ends and the next one picks up.

FoundationsF1 HTML & SemanticsF2 CSS FundamentalsF3 Layout: Flexbox & GridF4 JavaScriptF5 The DOM & EventsF6 AccessibilityCore FrontendT1 TypeScriptT2 React FundamentalsT3 State ManagementT4 Data Fetching & CachingT5 Routing & FormsT6 TestingProductionP1 Build Tools & BundlersP2 Rendering: CSR / SSR / SSGP3 PWA & OfflineP4 Performance & Core Web VitalsP5 Frontend SecurityP6 Deployment & CI/CD
Track order matters more than rung order inside a track: finish a track's last rung before starting the next track.

Worked example: a three-hours-a-week plan

Say you have three focused hours a week — an evening or two. Take the rungs in order and never split one across two weeks; a rung that would push the week past three hours starts the next week. The rung times add up to 17h 45m.

WeekRungsTime
Week 1F1 HTML & Semantics, F2 CSS Fundamentals, F3 Layout: Flexbox & Grid2h 45m
Week 2F4 JavaScript, F5 The DOM & Events2h 25m
Week 3F6 Accessibility, T1 TypeScript1h 55m
Week 4T2 React Fundamentals, T3 State Management2h 15m
Week 5T4 Data Fetching & Caching, T5 Routing & Forms, T6 Testing2h 50m
Week 6P1 Build Tools & Bundlers, P2 Rendering: CSR / SSR / SSG, P3 PWA & Offline2h 50m
Week 7P4 Performance & Core Web Vitals, P5 Frontend Security, P6 Deployment & CI/CD2h 45m

That is 7 weeks of reading. The Build-it exercise on each rung is extra and is where most of the learning happens, so plan to spend at least as long building as reading — or halve the pace and do both in the same week.

What each track costs in time

The rung times above, added up per track. Use it to plan the slow stretch: a track that takes a larger share of the total is where the plan above spends more weeks.

TrackRungsTimeShareLongest rung
1. Foundations66h 5m34%F4 JavaScript (1h 30m)
2. Core Frontend66h 5m34%T2 React Fundamentals (1h 15m)
3. Production65h 35m31%P2 Rendering: CSR / SSR / SSG (1h 5m)

Common mistakes on the Frontend Engineer path

  • Starting with React before JavaScript

    Skip closures and the event loop (F4) and React (T2) feels like magic until a useEffect reads a stale value. The bug is a closure, not React.

  • Div soup patched with ARIA

    A div with a click handler needs a role, a tabindex and key handlers to match a button, and usually misses one. Use the native element first (F1); ARIA is for what HTML cannot say (F6).

  • Putting server data in a global store

    Copying API responses into Redux means hand-writing caching, refetching and staleness. T4 treats server state as its own thing; keep UI state local (T3) and let a data layer own the rest.

  • Testing internals

    Tests that assert on component state or call private methods break on every refactor and pass when the screen is wrong. Assert on what the user sees (T6).

  • Leaving performance to the end

    Lazy-loading the hero image delays LCP; images without width and height cause layout shift. These are P4 basics, and they are cheap to get right on day one, expensive to retrofit.

Where this shows up: jobs and interviews

  • The day-to-day work

    Building components from designs, wiring them to APIs, fixing layout and browser bugs, reviewing pull requests, and keeping an eye on bundle size and Core Web Vitals.

  • What interviews probe

    JavaScript fundamentals such as closures, the event loop and this (F4), and a live UI build such as an autocomplete with debounce and loading states (F5, T4). Some loops add a frontend system design round on rendering and data fetching (P1, P2, T4).

  • The follow-up questions

    “How would a keyboard user do this?” and “Why is this page slow?” are common follow-ups to a build exercise. They come straight from F6 and P4.

  • Showing it in a portfolio

    One deployed app with a public URL beats many tutorials. Make it keyboard-operable, give it component tests, and write a short note on why you chose its rendering strategy and what its slowest metric is.

Check yourself

Open a question only after you have answered it out loud. If one stumps you, the rung in brackets is where to go back to.

A search box fetches on every keystroke, and sometimes shows results for an older query. What two fixes do you make?

Debounce the input so you send fewer requests, and abort (or ignore) any request that is not the latest, so a slow old response cannot overwrite a newer one. (F4, T4)

You are building a public marketing page and a logged-in dashboard. Which rendering strategy for each?

Static generation or SSR for the marketing page: it needs SEO and a fast first paint, and its content changes rarely. The dashboard has no SEO need and per-user data, so client rendering (or SSR without caching) fits. (P2)

You must display HTML written by users. Why is el.innerHTML = input a trap, and what do you do instead?

Raw HTML can carry scripts and event-handler attributes, which is XSS. Sanitize it with an allowlist sanitizer, add a Content Security Policy as a second layer, and for plain text set textContent so it is never parsed as HTML. (P5)

A list of 1,000 rows has a click listener on every row and feels slow. What is the fix?

Event delegation: one listener on the parent, using event.target.closest('li') to find the row. Events bubble, so one listener covers every row, including rows added later. (F5)

Frontend Engineer roadmap — frequently asked questions

The common questions before you start — how long it takes, whether to follow it in order, and how it stays current.

How long does this roadmap take?

It runs 18 stations across 3 tracks — roughly ~16h of focused learning, plus the time you spend actually building. It is self-paced, so most people work through it over a few weeks, an evening or a single station at a time.

Do I have to follow the stations in order?

The tracks are ordered so each station builds on the one before, and following them start to finish is the intended path. But every station also stands alone — if you already have the foundations, jump straight to the part you need.

Is it free?

Yes. The whole roadmap, and every handbook, lab, and challenge it links to, is free and open — no sign-up and no paywall.

How is the roadmap kept current?

It teaches the durable fundamentals of the role first, then the tooling and the AI-era shifts on top — so most of it stays relevant as individual tools churn, and it is revised as the role itself changes.

Who is this roadmap for?

Anyone stepping into or leveling up in the Frontend Engineer role — whether you are switching in, early-career, or a senior filling gaps. Start where you are; the ladder shows what is left.

Finished this one? 0 / 31 Roadmaps done
NextData Structures & Algorithms Roadmap Closest roadmap to this one

Explore the topic

See this alongside everything else on the same subject — handbooks, system designs, challenges and tools, in one place.

More Roadmaps