Roadmaps › Web Development
Frontend Developer Roadmap
Build fast, beautiful, accessible websites — HTML, CSS, JavaScript, React and the tools around them.
Level: Beginner → Intermediate · Duration: 4–5 months
Step 1: How the web works
What happens between typing a URL and seeing a page.
Before writing any web page, understand what happens when someone opens a website: the browser asks DNS for the server's address, connects to it, requests the page over HTTP, and then turns the HTML, CSS and JavaScript it receives into what you see. Knowing this flow makes every later topic — performance, APIs, caching, security — much easier to understand.
- The client–server model: who asks, who answers
- The journey of a request: URL → DNS → TCP/TLS → HTTP → response
- What the browser does with HTML, CSS and JS (parsing and rendering)
- The difference between frontend (runs in the browser) and backend (runs on a server)
Resources: Notes: What Happens When You Type a URL
HTTP & HTTPS
Requests, responses, status codes, headers.
HTTP is the language browsers and servers use to talk. Every request has a method (GET, POST…), a URL and headers; every response has a status code, headers and a body. HTTPS is HTTP inside an encrypted TLS connection, so nobody in between can read or change the data.
- Methods: GET, POST, PUT, PATCH, DELETE and when each is used
- Status codes: 200, 201, 301/302, 400, 401, 403, 404, 500
- Headers such as Content-Type, Authorization, Cache-Control, cookies
- Why HTTPS matters and what the padlock in the address bar means
- Inspecting real requests in the browser DevTools Network tab
DNS & hosting
How a domain finds a server.
Computers find each other by IP address, but people remember names. DNS is the internet's phonebook that turns a domain like codify.dev into an IP address. Hosting is the computer (server) that stores your site and answers requests — for a frontend this is often a static host or CDN.
- What a domain name, IP address and DNS record (A, CNAME) are
- How DNS lookup works step by step (resolver, root, TLD, authoritative server)
- Static hosting vs a server you manage
- What a CDN is and why it makes sites faster
Browsers
Rendering, DevTools, the console.
The browser is where all your frontend code runs. It parses HTML into the DOM, CSS into style rules, combines them into a layout, paints pixels and runs JavaScript. DevTools — the panel you open with F12 — is the tool you will use every single day to inspect, debug and measure your pages.
- Rendering steps: DOM → CSSOM → layout → paint
- DevTools tabs: Elements, Console, Network, Sources, Application
- Using console.log and breakpoints to debug
- Device mode for testing mobile screens
Step 2: HTML
The structure of every web page.
HTML (HyperText Markup Language) describes the structure and meaning of a page: headings, paragraphs, links, images, lists, forms. It is not a programming language — it is markup — but writing it well (with the right elements) is the foundation for good styling, accessibility and SEO.
- Document structure: doctype, html, head, body
- Text, headings, links, images, lists and tables
- Attributes such as href, src, alt, id and class
- Block vs inline elements
- Validating your HTML and fixing common mistakes
Resources: HTML documentation · HTML cheat sheet
Semantic elements
header, nav, main, article, footer.
Semantic elements describe what content is, not how it looks — header, nav, main, article, section, footer instead of a pile of divs. Screen readers, search engines and other developers all understand a semantic page better.
- header, nav, main, section, article, aside, footer
- When a div or span is still the right choice
- Using exactly one h1 and a logical heading order
- figure, figcaption, time and other meaningful tags
Forms & inputs
Labels, validation, accessible forms.
Forms are how users send data — logins, searches, sign-ups, checkout. HTML gives you many input types with built-in validation, and correct labels make forms usable on phones and with screen readers.
- form, input, label, textarea, select, button
- Input types: text, email, password, number, date, checkbox, radio, file
- Built-in validation: required, min/max, pattern, maxlength
- Connecting labels to inputs with for/id
- GET vs POST form submission
SEO basics (optional)
Titles, meta descriptions, headings.
Search Engine Optimisation helps Google understand and rank your pages. Much of it is plain good HTML: a clear title, a meta description, proper headings, descriptive link text and alt text on images.
- title and meta description tags
- Heading structure and descriptive link text
- Open Graph tags for nice link previews on WhatsApp/LinkedIn
- sitemap.xml and robots.txt
Accessibility
Alt text, landmarks, keyboard navigation.
Accessibility (a11y) means everyone can use your site — including people using screen readers, keyboards only, or zoomed-in screens. Most of it comes from semantic HTML, good labels and enough colour contrast, and it also improves SEO.
- alt text for images (and empty alt for decorative ones)
- Keyboard navigation and visible focus styles
- Labels, landmarks and when to use aria-* attributes
- Colour contrast and not relying on colour alone
- Testing with Lighthouse and a screen reader
Step 3: CSS
Make it look good on every screen.
CSS (Cascading Style Sheets) controls how HTML looks: colours, fonts, spacing and layout. The "cascading" part decides which rule wins when several apply. Strong CSS skills are what separate a page that works from one that looks professional on every screen.
- Writing rules: selectors, properties and values
- Colours, units (px, rem, %, vw/vh) and typography
- The cascade, inheritance and specificity
- Layout with Flexbox and Grid
- Responsive design for phones, tablets and desktops
Resources: CSS documentation · CSS cheat sheet
Selectors & specificity
Why a rule wins over another.
Selectors pick which elements a rule applies to. When two rules conflict, specificity decides the winner — an id beats a class, a class beats an element — and if they tie, the later rule wins. Understanding this ends most "why isn't my CSS working?" moments.
- Element, class, id, attribute and universal selectors
- Descendant, child and sibling combinators
- Pseudo-classes (:hover, :focus, :nth-child) and pseudo-elements (::before)
- How specificity is calculated and why to avoid !important
Box model
margin, border, padding, box-sizing.
Every element is a rectangular box made of content, padding, border and margin. Getting widths and spacing right depends on understanding how these add up — and box-sizing: border-box makes it much simpler.
- Content, padding, border and margin
- box-sizing: content-box vs border-box
- Margin collapsing between vertical blocks
- display: block, inline, inline-block and none
Flexbox & Grid
Layouts for any design.
Flexbox lays items out in one direction (a row or a column) and is perfect for navbars, toolbars and centring. Grid works in two directions at once and is ideal for page layouts and card grids. Modern layouts usually combine both.
- display: flex, flex-direction, justify-content, align-items, gap
- flex-grow, flex-shrink, flex-basis and flex-wrap
- display: grid, grid-template-columns, the fr unit, repeat() and minmax()
- Placing items with grid areas
- Choosing between Flexbox and Grid
Responsive design
Media queries, rem/em, mobile-first.
More than half of visitors use phones, so pages must adapt to any width. Responsive design uses flexible units, fluid images and media queries; the mobile-first approach styles the small screen first and adds rules for bigger ones.
- The viewport meta tag
- Mobile-first media queries (min-width)
- Relative units: rem, em, %, vw, clamp()
- Responsive images and avoiding horizontal scroll
- Testing in DevTools device mode
Animations (optional)
transitions, keyframes, prefers-reduced-motion.
Small animations make interfaces feel alive — a button that eases on hover, a menu that slides in. CSS transitions animate between two states; keyframe animations handle more complex motion. Always respect users who prefer reduced motion.
- transition: property, duration, easing
- @keyframes and the animation property
- Animating transform and opacity for smooth performance
- prefers-reduced-motion media query
Step 4: JavaScript
Make pages interactive.
JavaScript is the programming language of the web: it makes pages react to clicks, fetch data, update without reloading and much more. It is also used on servers (Node.js), so learning it well opens both frontend and backend doors.
- Variables (let/const), types and operators
- Functions, arrays, objects and loops
- Working with the DOM and events
- Asynchronous code with promises and async/await
- Modern ES6+ syntax used in every codebase
Resources: ▶ Chai aur JavaScript · JavaScript documentation
Language basics
Types, functions, arrays, objects, loops.
Start with the core language before touching frameworks: values and types, functions, arrays and objects, and control flow. Pay special attention to how this, scope and closures work — they come up in interviews and in real bugs.
- let vs const vs var, primitive vs reference types
- Functions, arrow functions, default and rest parameters
- Array methods: map, filter, reduce, find, some
- Objects, destructuring and the spread operator
- Scope, hoisting and closures
DOM & events
Change the page when users act.
The DOM (Document Object Model) is the browser's live tree of your page. JavaScript can find elements, change their text, classes and styles, and listen for events like clicks and key presses — this is how plain JS makes pages interactive.
- querySelector and querySelectorAll
- Changing textContent, classList, attributes and styles
- addEventListener, the event object and preventDefault
- Event bubbling and delegation
- Creating and removing elements
Async & fetch
Promises, async/await, calling APIs.
JavaScript runs on one thread, so slow work like network calls happens asynchronously. Promises represent a value that will arrive later, async/await makes that code read top to bottom, and fetch is how you call APIs from the browser.
- The event loop, callbacks and why async exists
- Promises: then, catch, Promise.all
- async/await with try/catch
- fetch: GET and POST requests, JSON, status checks
- Showing loading and error states
Resources: Notes: Promises & Async/Await
ES modules
import / export, splitting code into files.
Modules let you split code into files that import and export what they need, instead of one giant script. Every modern project and build tool is built on ES modules.
- export (named and default) and import
- Using type="module" in the browser
- Organising code into small files by feature
- Importing packages from npm
Step 5: Git & GitHub
Version control every developer uses.
Git records every change to your code so you can go back in time, try ideas on branches and work with others without overwriting each other. GitHub hosts your repositories online — and your GitHub profile becomes part of your resume.
- Why version control matters
- Repositories, commits and history
- Branches, merging and pull requests
- Writing good commit messages
Resources: Git documentation · ▶ Complete Git and GitHub Tutorial
Everyday Git
commit, branch, merge, push.
A handful of commands cover most daily work: check what changed, stage it, commit it, push it, and pull others' changes. Branches keep new features separate until they are ready.
- git init, clone, status, add, commit, log
- git push and git pull with a remote
- Creating and switching branches; merging
- Fixing merge conflicts
- .gitignore for files that should not be committed
GitHub Pages
Host static sites for free.
GitHub Pages hosts static websites for free straight from a repository — perfect for your first projects and a portfolio. Every push updates the live site.
- Enabling Pages for a repository
- Deploying a plain HTML/CSS/JS project
- Custom domains and HTTPS on GitHub Pages
Step 6: Package managers & build tools
How modern projects are set up.
Real projects use hundreds of open-source packages and need code bundled, minified and optimised before it ships. npm installs and manages packages; build tools like Vite give you a fast dev server and an optimised production build.
- What package.json and node_modules are
- Dependencies vs devDependencies
- npm scripts for dev, build and test
- What bundling and minification do
Resources: Node.js documentation
npm
Install, scripts, package.json.
npm (Node Package Manager) comes with Node.js. You use it to install libraries, run project scripts and lock exact versions so every developer gets the same setup.
- npm init, install, uninstall, update
- package.json scripts
- package-lock.json and semantic versioning (^1.2.3)
- npx for running tools without installing them globally
Vite
Dev server and production builds.
Vite starts a development server in milliseconds and updates the page instantly when you save. For production it bundles and minifies your code. It is the default way to start React projects today.
- npm create vite@latest
- The dev server and hot module replacement
- npm run build and the dist folder
- Environment variables with import.meta.env
Linting & formatting (optional)
ESLint and Prettier.
ESLint catches likely bugs and bad patterns as you type; Prettier formats code the same way for everyone. Together they keep a codebase consistent and reviews focused on logic.
- Setting up ESLint and fixing its warnings
- Prettier and format-on-save in VS Code
- Running both in CI or a pre-commit hook
Step 7: React
The most popular UI library.
React is a library for building user interfaces from components. You describe what the UI should look like for a given state, and React updates the page efficiently when that state changes. It is the most requested frontend skill in job listings.
- Thinking in components and JSX
- Props, state and one-way data flow
- Hooks: useState, useEffect and friends
- Lists, keys and conditional rendering
- Routing and fetching data from an API
Resources: ▶ Chai aur React · React documentation
Components, props, state
Thinking in components.
A component is a function that returns UI. Props pass data from parent to child; state is data a component owns and can change. When state changes, React re-renders that component.
- Function components and JSX rules
- Passing props and children
- useState and updating state correctly (never mutate)
- Lifting state up to share it between components
- Rendering lists with stable keys
Hooks
useState, useEffect, useRef, custom hooks.
Hooks let function components remember things and react to changes. useState stores values, useEffect runs side effects like fetching data, useRef keeps a value or DOM reference without re-rendering, and custom hooks let you reuse logic.
- useState and useEffect (and the dependency array)
- useRef, useMemo and useCallback — when they help
- useContext for sharing data without prop drilling
- Writing your own custom hook
- The rules of hooks
Routing
React Router.
Single-page apps change "pages" without reloading the browser. React Router maps URLs to components, reads URL parameters and lets you protect pages that need login.
- Routes, Link and NavLink
- URL params (useParams) and query strings
- Nested routes and layouts
- Protected routes and redirects
Forms & data fetching
Controlled inputs, loading and error states.
Most apps load data from an API and send form data back. Controlled inputs keep form values in state; data fetching needs loading, error and empty states so users always know what is happening.
- Controlled inputs and form submission
- Client-side validation and error messages
- Fetching in useEffect (and cleaning up)
- Loading, error and empty states
- Optional: React Query / TanStack Query for caching
Next.js (optional)
Server rendering and file-based routing.
Next.js is a React framework that adds server-side rendering, file-based routing and API routes. Pages can be rendered on the server for faster loads and better SEO.
- File-based routing with the app/ directory
- Server components vs client components
- Static generation vs server rendering
- Deploying a Next.js app to Vercel
Step 8: TypeScript (optional)
Catch bugs before running your code.
TypeScript is JavaScript with types. You describe the shape of your data once and the editor warns you about mistakes before the code runs — a typo in a property name, a missing argument, a possibly-undefined value. Most large React codebases use it.
- Basic types, arrays, unions and optional values
- Interfaces and type aliases
- Generics in simple cases
- Configuring tsconfig.json
Resources: TypeScript documentation · ▶ Chai aur TypeScript
Types & interfaces
Annotate props, state and API data.
Start by typing the data that moves through your app — API responses, component props, form values. Good types act as documentation and catch whole classes of bugs.
- Primitive types, arrays and objects
- interface vs type
- Union types and narrowing with if checks
- Optional (?) and readonly properties
TypeScript with React
Typed components and hooks.
In React, TypeScript checks that every component receives the right props and that state and events are used correctly.
- Typing props and children
- Typing useState and useRef
- Event types (ChangeEvent, FormEvent)
- Typing API responses
Step 9: Styling at scale
Keep big projects consistent.
Plain CSS files become hard to manage as an app grows. Utility-first CSS, scoped styles and component libraries keep styles consistent and stop one change from breaking another page.
- Design tokens: colours, spacing and fonts as variables
- Avoiding global CSS conflicts
- Choosing between Tailwind, CSS Modules and a component library
Tailwind CSS
Utility classes.
Tailwind gives you small utility classes (flex, p-4, text-lg) that you combine directly in your markup. You rarely write custom CSS, and designs stay consistent because everyone uses the same scale.
- Installing Tailwind with Vite
- Spacing, colour, typography and layout utilities
- Responsive prefixes (md:, lg:) and states (hover:, focus:)
- Customising the theme
CSS Modules / styled-components (optional)
Scoped styles.
CSS Modules scope class names to one component automatically, so .button in one file never clashes with another. styled-components writes CSS inside JavaScript. Both solve the "global CSS" problem.
- Importing a .module.css file
- How class names get scoped
- When CSS-in-JS is worth it
Component libraries (optional)
shadcn/ui, MUI.
Libraries like shadcn/ui and MUI give you ready, accessible buttons, dialogs, menus and tables so you can build faster and focus on your app.
- Using pre-built accessible components
- Theming a library to match your design
- Knowing when to build your own instead
Step 10: Performance & testing
Fast pages rank better and feel better.
Fast pages keep users and rank higher on Google; tests let you change code without fear. Both are signs of a professional frontend developer.
- Core Web Vitals (LCP, CLS, INP)
- Measuring with Lighthouse
- Unit and component tests
Web performance
Lighthouse, lazy loading, image sizes, code splitting.
Most slow sites ship too much JavaScript or too-large images. Measure first with Lighthouse, then fix the biggest problems: compress images, lazy-load what is below the fold and split code by page.
- Running a Lighthouse audit and reading it
- Image formats (WebP/AVIF), sizes and lazy loading
- Code splitting with dynamic import()
- Caching and avoiding layout shift
Testing
Vitest + React Testing Library.
Tests check that your components still work after you change things. Vitest runs tests fast; React Testing Library tests components the way a user would use them.
- Writing a first unit test with Vitest
- Rendering components and querying by role/text
- Simulating clicks and typing
- Mocking API calls
Step 11: Portfolio & projects
What gets you interviews.
Recruiters look at what you have built. Two or three polished, deployed projects with clean code on GitHub are worth more than a long list of skills on a resume.
- Picking projects that show different skills
- Writing a good README with screenshots
- Deploying everything with a live link
Resources: Interview questions: JavaScript · ▶ Next.js 15 Tutorial
Portfolio website
Your projects, skills and contact.
Your portfolio is a simple site about you: who you are, what you have built and how to contact you. Keep it fast, responsive and focused on projects.
- About, projects, skills and contact sections
- Project cards with live and GitHub links
- Fast loading and good mobile layout
2–3 React projects
e.g. weather app, e-commerce UI, dashboard.
Build projects that use real APIs and real features — not just tutorials copied line by line. Each one should teach you something new.
- A data-driven app (weather, movies, news) using a public API
- An e-commerce UI with a cart and filters
- A dashboard with charts, forms and authentication
Deploy
Vercel or Netlify with a custom domain.
Vercel and Netlify deploy a frontend from GitHub in minutes and redeploy on every push. A custom domain makes your portfolio look professional.
- Connecting a GitHub repo to Vercel or Netlify
- Environment variables in production
- Adding a custom domain