Skip to main content
AIDevOps
  • Learn
  • Learning Paths
  • Practice
  • Open Source
  • Books
  • Engineering

    AI DevOpsThe full map of building and operating AI servicesLLMOpsLLM deployment Β· evaluation Β· observabilityHands-on ProjectsBuild AI Agent projects

    Knowledge

    DocsTechnical documentationBlogEngineering articlesPloggerDevelopment log feed

    Validate

    Certification3-level skills certification Β· coming soon
AI Models
LlamaTutorial|MistralTutorial|GemmaTutorial|DeepSeekTutorial|QwenTutorial
🎨 Frontend
Frontend Intro & RoadmapJavaScriptTypeScript|ReactNext.js|VueNuxt|Electron
πŸ€– AI Applied Development
Applied AI Intro & RoadmapHugging FaceLangChainLlamaIndexLLMOps|LangGraphMCPMulti-AgentAgent Evaluation
🧠 AI Core
AI Intro & RoadmapML FundamentalsLLM Fundamentals|Python AIC++|PyTorchTensorFlowJAX
🧠 AI Agent Development
Finance AI AgentLLM API ServerStock Investing AgentAIOps AI AgentEducation AI AgentCoding AI Agent
🌱 Spring Cloud
Spring Intro & RoadmapSpring Cloud GatewaySpring BootJava|Spring AISpring SecuritySpring BatchSpring JPA
🐳 DevOps
DevOps Intro & RoadmapLinuxDockerCI/CD|Kubernetes BasicsK8s AdvancedPrometheusGrafana
🧱 Infrastructure
Infrastructure Intro & RoadmapNginxRedis
☁️ Cloud
Cloud Intro & RoadmapAWSGCPAzureNCPCloudflare
πŸ“± Mobile
Mobile Intro & RoadmapKotlinAndroidFlutter
βš™οΈ Backend
Backend Intro & RoadmapPython BasicsFastAPIDjangoFlask|CGoGinNode.js
πŸ’Ύ Database
DB Intro & RoadmapCore SQLOracleMySQLPostgreSQL|MongoDBVector DB
πŸ§ͺ Testing
k6JMeternGrinder
AIDevOps

Engineering AI. From Code to Production.
An engineering learning platform for building and operating AI and AI Agents

Learn

  • All Guides
  • Learning Paths
  • AI Tutorial
  • Practice
  • Books

Resources

  • AI DevOps
  • LLMOps
  • Hands-on Projects
  • Docs
  • Blog
  • Plogger
  • Open Source
  • Certification (coming soon)

Start Here

  • AI Core Roadmap
  • AI Applied Development Roadmap
  • Spring Cloud Roadmap
  • DevOps Roadmap
  • Infrastructure Roadmap

Β 

  • Cloud Roadmap
  • Frontend Roadmap
  • Mobile Roadmap
  • Backend Roadmap
  • Database Roadmap
Β© 2026 AIDevOps. All rights reserved.
Terms of ServicePrivacy PolicySitemaptestforge.kr
  1. Home
  2. Learn
  3. Frontend
  4. Frontend Intro & Roadmap
The first guide for newcomers to the frontend

🧭 Frontend Intro & Roadmap Complete Guide

Visitors

A starting point for anyone new to web frontend development. It covers how the browser draws the screen, the roles of HTML, CSS, and JavaScript, why frameworks such as React and Vue are needed, rendering strategies (CSR, SSR, SSG), and a learning roadmap from JavaScript basics to deploying with Next.js and Nuxt.

  • Beginner
  • Updated Oct 1, 2026
  • ~7 min read
  • 13 sections
  • 1 code examples
🧭
The big picture of the frontendHow browser rendering worksChoosing a frameworkUnderstanding rendering strategiesFrontend learning order

Related frameworks & environments

✨JavaScriptβ†’πŸ”·TypeScriptβ†’βš›οΈReactβ†’β–²Next.jsβ†’πŸ’šVueβ†’πŸ’‘Nuxtβ†’

Contents

0 / 16
  1. How to use this guide
  2. Architecture diagrams
  3. What the frontend is
  4. The three pillars: HTML, CSS, JS
  5. How the browser draws the screen
  6. Why a framework
  7. Your first component
  8. Rendering strategies
  9. The tooling ecosystem
  10. Before you start
  11. Step-by-step roadmap
  12. 12-week study plan
  13. Project ideas
  14. Common mistakes
  15. Key terms
  16. Frequently asked questions
Contents 16 sections
  1. How to use this guide
  2. Architecture diagrams
  3. What the frontend is
  4. The three pillars: HTML, CSS, JS
  5. How the browser draws the screen
  6. Why a framework
  7. Your first component
  8. Rendering strategies
  9. The tooling ecosystem
  10. Before you start
  11. Step-by-step roadmap
  12. 12-week study plan
  13. Project ideas
  14. Common mistakes
  15. Key terms
  16. Frequently asked questions

How to use this guide

How to read it

Understanding Frontend Intro & Roadmap as a real-world workflow

A starting point for anyone new to web frontend development. It covers how the browser draws the screen, the roles of HTML, CSS, and JavaScript, why frameworks such as React and Vue are needed, rendering strategies (CSR, SSR, SSG), and a learning roadmap from JavaScript basics to deploying with Next.js and Nuxt. Rather than listing concepts, this guide is organized so you can follow the content in the order you have to make decisions on a real project.

Key perspective

Frontend / app development

Do not stop at drawing the screen: look at state, data requests, routing, accessibility, and the unit of deployment together.

The big picture of the frontendHow browser rendering worksChoosing a frameworkUnderstanding rendering strategiesFrontend learning order

Architecture diagrams

To make what you read stick, it helps to capture the flow as a picture first. The two diagrams below are reference maps you can keep coming back to while learning Frontend Intro & Roadmap.

Learning flow

Rendering diagram…

Architecture view

Rendering diagram…

What the frontend is

When you first open Frontend Intro & Roadmap, the big picture matters more than individual commands. This section starts with the problems the concepts ahead were created to solve.

The frontend is everything the user sees and touches directly. That includes buttons, input fields, animations, page navigation, and presenting data from the server in a readable way.

Where the frontend used to be "turning a design into HTML", it is now a full software engineering discipline responsible for state management, data fetching, performance optimization, accessibility, and SEO. Most of the service quality a user perceives is decided in the frontend.
What frontend developers care aboutExample
UI implementationTurning a design mockup into a responsive layout
InteractionForm validation, drag and drop, modals
Data fetchingAPI calls, handling loading and error states, caching
PerformanceInitial load speed, image optimization, code splitting
AccessibilityKeyboard operation, screen reader support, color contrast
SEOPage structure and metadata that search engines can read

HTML Β· CSS Β· JavaScript: the three pillars of the web

HTML Β· CSS Β· JavaScript: the three pillars of the web is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Every web page is built with three languages. Compared to a house, HTML is the frame, CSS is the interior, and JavaScript is the working machinery, like electricity and plumbing. React and Vue are, in the end, tools for handling these three more efficiently.
LanguageRoleKey topics to learn
HTMLStructure and meaning of the documentSemantic tags (header, nav, main, article), forms, accessibility attributes
CSSAppearance and layoutBox model, Flexbox, Grid, responsive design (media queries), variables
JavaScriptBehavior and data handlingDOM manipulation, events, async (Promise, async/await), fetch
TypeScriptJavaScript + a type systemType definitions, interfaces, generics β€” stability for large codebases

Tip

Even if you want to jump straight to a framework, build one to-do list app in plain JavaScript. You will feel what the framework does for you.

How the browser draws the screen

How the browser draws the screen is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

When you type a URL into the address bar, the browser fetches the HTML and draws the screen in the order below. Knowing this process lets you understand and fix "why the page is slow" and "why the layout flickers".
StepWhat happensPerformance point
1. HTML parsingReads the HTML and builds the DOM treeReduce needlessly deep DOM
2. CSS parsingReads the CSS and builds the CSSOMCSS blocks rendering, so put critical CSS first
3. JavaScript executionScripts can modify the DOMAvoid blocking the parser with defer / async
4. Render tree & layoutComputes the size and position of each elementAvoid code that triggers layout repeatedly
5. Paint & compositeDraws pixels and shows them on screentransform and opacity animations are cheap

Why a framework: keeping state and UI in sync

Why a framework: keeping state and UI in sync is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

When you build an app in plain JavaScript, you have to manage by hand "which part of the screen to fix every time the data changes". As the app grows, that synchronization becomes the main source of bugs.

Frameworks such as React and Vue solve this with the idea that "UI = f(state)". The developer changes only the state (the data), and the framework works out how to update the screen. The screen is also split into reusable components that are assembled together.
FrameworkTraitsMeta-frameworkGuides
ReactThe largest ecosystem, JSX, function components + HooksNext.jsReact, Next.js
VueLow barrier to entry, template syntax, reactivity systemNuxtVue, Nuxt
Svelte / AngularCompiler-based (Svelte), enterprise full stack (Angular)SvelteKit / --

Tip

React has the largest share of the job market. If you are picking your first one, React is the recommendation, but the concepts in Vue are nearly the same, so switching later is easy.

Your first component: when state changes, the screen changes

Here you look at Your first component: when state changes, the screen changes alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.

The React component below contains no code that edits the screen directly. Change only the state with setCount and React redraws the screen. This is declarative UI.
Counter.tsxTSX
import { useState } from 'react';

type Props = { label: string; step?: number };

export default function Counter({ label, step = 1 }: Props) {
  const [count, setCount] = useState(0);   // declare state

  return (
    <div className="counter">
      <p>{label}: {count}</p>
      {/* Change only the state and React redraws the screen */}
      <button onClick={() => setCount(count + step)}>+{step}</button>
      <button onClick={() => setCount(0)} disabled={count === 0}>Reset</button>
    </div>
  );
}

// Usage: <Counter label="Visitors" step={5} />

Rendering strategies: CSR Β· SSR Β· SSG

Rendering strategies: CSR Β· SSR Β· SSG is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Performance and SEO differ greatly depending on "where and when the HTML is produced". Meta-frameworks such as Next.js and Nuxt let you choose the strategy page by page. This site (aidevops.us) is itself built with static generation (SSG) in Next.js.
StrategyWhen the HTML is generatedProsConsBest for
CSR (Client-Side)In the browser after the JS runsLight server load, app-like interactionSlow initial load, weak SEOAdmin dashboards, screens behind login
SSR (Server-Side)On the server for every requestFresh data + SEOServer cost, response delayProduct detail, personalized pages
SSG (Static)Ahead of time at buildFastest, CDN delivery, cheapRebuild when data changesBlogs, documentation, landing pages
ISR / hybridStatic + periodic regenerationSSG speed + reasonable freshnessNeeds a cache strategyNews, catalogs

The tooling ecosystem

The tooling ecosystem is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

It looks like a lot of tools, but at first Vite (or Next.js) + TypeScript + ESLint is enough. Add the rest one at a time as the need arises.
CategoryToolsRole
RuntimeNode.jsRuns the dev server and build tools
Package managementnpm, pnpm, yarnInstalls libraries and manages versions
Build toolsVite, Turbopack, webpackModule bundling, dev server, optimization
StylingCSS Modules, Tailwind CSSManaging styles per component
State Β· dataTanStack Query, Zustand, PiniaServer data caching, global state
QualityESLint, Prettier, Vitest, PlaywrightLinting, formatting, unit and E2E tests
DeploymentVercel, Cloudflare Pages, NetlifyDeploying static and SSR apps

Before you start

Before you start is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Design skill is not required. But knowing basic principles such as spacing, alignment, and color contrast makes the same feature look far more polished.
AreaWhatHow much
HTML/CSSSemantic tags, Flexbox, Grid, responsive designBuild a simple landing page yourself
JavaScriptVariables, functions, array methods, objects, asyncRequired (JavaScript)
Browser developer toolsThe Elements, Console, Network, and Performance tabsFind out why a request failed
Gitcommit, branch, PRRequired
HTTP basicsGET/POST, status codes, JSON, CORSNeeded for API integration

Step-by-step roadmap: from web basics to production deployment

Step-by-step roadmap: from web basics to production deployment is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

StepGoalWhat to learnGuidesDone check
0. Web basicsBuild screens with HTML and CSSSemantic HTML, Flexbox/Grid, responsive design-A responsive personal intro page
1. JavaScriptPages that do thingsDOM, events, async, fetch, modulesJavaScriptA plain JS to-do app + API integration
2. TypeScriptSafer codeTypes, interfaces, generics, unionsTypeScriptConvert the JS app to TS
3. FrameworkComponent-based UIComponents, props, state, effects, routingReact or VueAn SPA wired to an API
4. Data & stateProduction-grade data handlingServer state caching, global state, form validationReactLoading, error, and empty states handled
5. Meta-frameworkPerformance and SEOSSR/SSG, file-based routing, server componentsNext.js, NuxtA blog with SEO metadata
6. QualityUI you can trustTesting, accessibility, Lighthouse performance measurement-Lighthouse score of 90 or higher
7. Full stack & deploymentA finished serviceAPI routes, authentication, deployment, monitoringNode.js, CloudflareDeployed on a custom domain

12-week study plan: 1-2 hours a day

12-week study plan: 1-2 hours a day is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Keeping each weekly deliverable as a deployed URL turns it straight into a portfolio. Vercel and Cloudflare Pages deploy for free once you connect a GitHub repository.
WeekTopicDeliverable
Weeks 1-2HTML, CSS, responsive designA mobile-friendly portfolio page
Weeks 3-4Core JavaScript + asyncA search page that uses a weather API
Week 5TypeScriptThe week 4 deliverable converted to TS
Weeks 6-7React basics (components, state, effects)A movie search SPA
Week 8Routing + forms + server stateLogin + message board UI
Weeks 9-10Next.js (SSR/SSG, server components)A markdown blog
Week 11Testing, accessibility, performanceTests + a Lighthouse report
Week 12Deployment + retrospectiveDeployed on a domain + README

Project ideas by difficulty

Project ideas by difficulty is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

In interviews, "what you thought about for the user experience" (loading states, error recovery, accessibility, performance numbers) makes a bigger difference than "what you built".
DifficultyProjectWhat you learn
β˜…β˜†β˜†Responsive portfolio siteHTML/CSS, layout
β˜…β˜†β˜†To-do app (local storage)State, events, localStorage
β˜…β˜…β˜†Movie and book search appAPI integration, debouncing, loading and error handling
β˜…β˜…β˜†Markdown blog (SSG)Next.js, routing, SEO
β˜…β˜…β˜…Real-time collaborative kanban boardDrag and drop, optimistic updates, WebSocket
β˜…β˜…β˜…Data dashboardCharts, virtualizing large lists, performance optimization

Common mistakes of frontend beginners

Common mistakes of frontend beginners is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Always remember that all frontend code is sent to the user browser. Whatever you send to the browser cannot be hidden.
MistakeProblemDo this instead
Starting React without JavaScript basicsCannot tell language syntax from framework rulesGet JS async and array methods solid first
Writing everything as a divWorse accessibility and SEOSemantic tags such as button, nav, and main
Leaving out loading and error statesBlank screens, a UX that feels frozenAlways handle all three states: loading, error, empty result
Making all state globalUnnecessary re-renders, more complexityKeep it in the nearest component and lift it only when needed
Overusing useEffectInfinite loops, duplicate requestsCompute derived values, use a query library for server data
Ignoring image optimizationSlow initial loadRight size and format (WebP/AVIF), lazy loading
Putting API keys in frontend codeAnyone can read them in the browserUse secret keys on the server only

Key terms

Key terms is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

TermOne-line explanation
DOMThe document object tree the browser builds by interpreting the HTML
ComponentA reusable piece of UI that makes up the screen
PropsInput values a parent passes to a child component
StateData that changes over time and affects the screen
HydrationAttaching JavaScript behavior to HTML received through SSR
BundlerA tool that bundles and optimizes many module files for the browser
CORSThe security policy that decides whether the browser allows calls to an API on another domain
Core Web VitalsUser experience performance metrics defined by Google, such as LCP, INP, and CLS
Responsive designDesign in which the layout adapts naturally to the screen size
Semantic HTMLWriting markup that expresses structure with tags that match their meaning

Tip

The next step is the JavaScript guide. Once you have async handling (Promise, async/await) down, you are ready to move on to React.

Frontend Intro & Roadmap: frequently asked questions

In what order should I study frontend development?

Build pages with HTML and CSS, add behavior with JavaScript, then move to TypeScript and a framework such as React. After that, widen out to fetching and showing data from a server, routing, state management, and a full-stack framework such as Next.js. Rather than rushing to a framework, understand JavaScript's asynchronous model and how the browser works first.

Should I learn React or Vue?

By job postings and ecosystem size React is larger, and Vue is regarded as easier to learn because its syntax is intuitive. The core ideas, components, state, and reactivity, are similar in both, so learning one deeply makes moving to the other easy. Choosing what the companies you want to work for use is the practical answer.

How do CSR, SSR, and SSG differ?

With CSR the browser runs JavaScript to draw the page, with SSR the server builds HTML for each request, and with SSG the HTML is built ahead of time at build. When search visibility and first-load speed matter, SSR or SSG has the edge; highly interactive screens used after login, such as admin pages, are fine with CSR. Mixing approaches per page within one service is normal.

Next guide β†’JavaScript