All roadmaps

TypeScript

Types that catch bugs before your users do.

For developers who know JavaScript: the type system from annotations to generics, narrowing, utility types, real-project configuration and typing React - with free resources on every topic.

Your progress0/43 topics · 0%

Progress is saved in this browser.

7 stages43 topics₹0 to follow

Filled nodes are the focus for this track; outlined ones can wait. Tap a topic to open it and mark it done, learning or skipped.

TypeScript in 2026Related roadmapsJavaScript roadmapReact roadmapNode.js roadmapProve it as you goReading is half of it. This roadmap isbacked by a free, scored TypeScriptcertification with a public verificationlink and a Frontend Engineer jobsimulation on real tickets - evidence arecruiter can check, not a claim. Marktopics done, learning or skipped as yougo; your progress carries into theclassic view.Get certified - freeJob simulationClassic viewKnow the demand before thesyntaxTypeScript in 2026What to learn in 2026Types that payoffTS with Reactand NodeAI writes TS firstWhich roles use itFrontend andfull stackBackend andtoolingFresher vs switcherWhat companies expectThe hiring barWhat interviewstestProof they verifyWhat gets you hiredA 90-day planProjects thatget readCertification and proofTS running, and the philosophyunderstood.Getting StartedWhy types & how TS runsAnnotations & inferenceThe compiler & tscType real application dataconfidently.Everyday TypesObjects, interfaces &aliasesUnions & literal typesArrays, tuples & enumsFunctions as typesLet the compiler prove yourcode safe.Narrowing & GuardsControl-flow narrowingDiscriminated unionsType predicates & assertionsunknown vs anyReusable code that staystype-safe.Generics & Advanced TypesGeneric functions & typesUtility typeskeyof, typeof & indexedaccessMapped & conditional types(reading level)Use TS the way teams do.TS in Real Projectsstrict modeTyping ReactDeclaration files &librariesValidating at the boundaryVerified proof of TS fluency.Prove ItCertificationFresher or experienced?Both tracks hold every topic. On the Fresher track thefoundations are filled and the later stages are outlined - dothem when a project needs them. On the Experienced track thefoundations are outlined and the later stages are filled. The2026 section at the top applies to both.Prefer a list?The classic view shows the same 6 stages as a sequentialchecklist with time estimates. Your marks are shared betweenthe two views.Open the classic view

Everything on this roadmap

Every stage and topic on the map, in reading order. Click any topic to open it.

The TypeScript roadmap, topic by topic

Every topic on the map in reading order, with what to learn and the resources we recommend. Main topics are open; open any subtopic to read it. Select a topic name to open it in the topic panel, where you can track your progress.

  1. 1. Know the demand before the syntax

    TypeScript in 2026

    2026

    TypeScript is the year's biggest story in programming languages: GitHub's Octoverse 2025 report found it overtook Python and JavaScript to become the most used language on GitHub in August 2025, adding more than a million contributors in a year, and credits AI coding tools, which emit typed code by default, for the push. For a learner that changes the order of things - TypeScript is no longer an advanced topic after JavaScript but the form in which most new web code is written and read. The four nodes answer what to learn, which roles use it, what companies expect and what gets you hired.

    What to learn in 2026

    Learn the type system as a tool for catching bugs and describing APIs - not as ceremony: inference, unions and narrowing, generics where they pay, utility types, strict mode and how to type the boundaries where data enters a program. Then TypeScript with the frameworks jobs use, React and Node, and the discipline of reading generated TypeScript critically. Octoverse 2025 puts it first on GitHub with 66 percent year-on-year contributor growth; the Stack Overflow 2025 survey shows it still rising. The sub-nodes order the three.

    Types that pay off

    The types that pay off are the ones at the edges and the ones that encode decisions: discriminated unions for state, narrowing instead of casting, generics for reusable functions and components, utility types for transforming shapes, and strict null checks everywhere. The Octoverse 2025 report's explanation for TypeScript's rise is that AI tools write it by default and teams keep it because the compiler catches what the tool got wrong - which is exactly the skill: know enough of the type system to read a generated signature and see the hole in it. Avoid any; learn unknown; learn when a type is lying.

    TS with React and Node

    In practice TypeScript lives inside React and Node: typing props, state, events and hooks on the front; typing requests, responses, database rows and environment variables on the back; and sharing types across the boundary with Zod or an OpenAPI-generated client so that the API contract is checked at compile time. The Stack Overflow 2025 survey has Node.js at 49 percent and React at 44 percent of developers, and the State of JavaScript 2025 survey shows React used by about 84 percent of JavaScript developers, so TypeScript with those two is the shape of most jobs. Next.js assumes it.

    AI writes TS first

    AI

    Ask an AI tool for a web component or a service in 2026 and it answers in TypeScript; GitHub's report credits that default for TypeScript's climb to first place and reports 80 percent of new developers using Copilot within their first week. The Stack Overflow 2025 survey adds the caveat: 46 percent of developers distrust AI output. The working skill is therefore reading generated TypeScript for the three classic faults - a type widened to any, a cast that hides a runtime shape, an optional that was never handled - and turning the compiler's errors into the review checklist the tool did not run.

    Which roles use it

    TypeScript is now the default language of frontend and full stack work, a strong choice for Node backends and the language most developer tooling and AI SDKs are written in. The sub-nodes name the frontend and full stack roles, the backend and tooling roles, and the fresher and switcher routes into them.

    Frontend and full stack

    Frontend and full stack roles are where TypeScript is simply assumed: React with TypeScript, Next.js, typed data fetching, typed forms and a component library. The Stack Overflow 2025 survey's most common developer type is full stack, and job descriptions for both now list TypeScript ahead of JavaScript. A frontend engineer who can type the API boundary and a full stack engineer who shares types across it are the two shapes most teams hire; the Frontend and Full Stack roadmaps give the rest of each path.

    Backend and tooling

    On the server, TypeScript on Node with Express, Nest or Hono is one of the most common backend stacks for product companies, and nearly all developer tooling - build tools, CLIs, AI SDKs, agent frameworks - is written in it. Octoverse 2025 ties TypeScript's first place partly to that tooling and AI ecosystem. Backend and platform roles that list TypeScript expect typed database access, typed configuration and a tested API; tooling roles expect you to publish a package. Both are routes into AI engineering, where the SDKs are TypeScript first.

    Fresher vs switcher

    A fresher should learn TypeScript immediately after the JavaScript basics rather than years later, because every project from then on reads better and every AI draft is typed anyway. A switcher from another typed language - Java, C#, Go - finds TypeScript familiar and should spend their time on the structural typing differences and the ecosystem. HackerRank's 2025 report found early-career hiring the hardest hit, so a deployed, typed project is the fresher's best evidence; on this map freshers get the basics filled and the advanced types outlined, experienced learners the reverse.

    What companies expect

    Companies expect TypeScript as a given on web teams in 2026: strict mode on, types at the boundaries, generics used where they earn their keep, and generated code reviewed for the places where a type was widened to any to make an error go away. The sub-nodes cover the bar, what interviews test and what gets verified.

    The hiring bar

    The bar is TypeScript used as a design tool: strict mode, no escape hatches without a comment, types at every boundary, generics only where they remove duplication, and generated code reviewed for the places a type was loosened. The Work Trend Index found 66 percent of leaders unwilling to hire without AI skills; for TypeScript teams that means using the tools and knowing when the compiler is being lied to. A candidate who can explain a discriminated union in their own project is at the bar.

    What interviews test

    Expect to type something live - a function, a component, an API response - and explain narrowing, unions, generics and the difference between type and interface; expect a practical build in a typed React or Node project, often with an AI tool allowed; expect questions about where any crept into your code and why. HackerRank's 2025 report says 66 percent of developers prefer practical assessments and that they are now standard. The strongest answer is a story about a bug the types caught before production.

    Proof they verify

    Reviewers read the types first: a repository whose types describe the domain, a shared contract between front and back, strict mode on, and tests that would fail if a shape changed. A deployed project with that shape beats a longer one without it; OneRoadmap's free TypeScript certification with its public verification link beats a course badge; a note on what the AI tool typed and what you tightened is now part of the proof.

    What gets you hired

    A deployed TypeScript project with a typed API boundary, a repository where the types explain the design, a verified certification and a clear account of how AI tools were used. The sub-nodes give the ninety-day plan, the projects that get read and the proof that counts.

    A 90-day plan

    Month one: the type system on small programs - unions, narrowing, generics, utility types, strict mode - with the JavaScript basics in place. Month two: a typed React or Node application with a shared API contract, deployed, built with an AI tool and reviewed through the compiler's errors. Month three: tests, a readme that explains the types as design, the TypeScript certification, and twenty targeted applications a week. Keep the log of what the tool typed loosely and what you fixed.

    Projects that get read

    Projects that get read show types doing work: a typed client for a public API generated from its OpenAPI document; a form library with validated, inferred types; a small full stack app where the server and client share one schema; a published npm package with a typed interface and tests. Each has a live link or a package page and a readme. The World Economic Forum's Future of Jobs 2025 report says 39 percent of skills change by 2030; TypeScript's rise to first place on GitHub in a single year is that change, and a project on it is the proof you moved with it.

    Certification and proof

    Proof is what a reviewer verifies in a minute: OneRoadmap's free TypeScript certification with a public link, a GitHub profile with real commits in typed projects, a deployed app or a published package, and a written account of your AI workflow. With over 180 million developers on GitHub and TypeScript its most used language, the bar for being noticed is verifiable work.

  2. 2. TS running, and the philosophy understood.

    Getting Started

    TS running, and the philosophy understood.

    Time: about 1 week. Topics: Why types & how TS runs · Annotations & inference · The compiler & tsc.

    Why types & how TS runs

    Optional on the Experienced track

    Static checking at build time, erasure at runtime - TS is JavaScript with a spell-checker for logic.

    Annotations & inference

    Optional on the Experienced track

    When to annotate and when inference does it better - typing variables, params and returns.

    The compiler & tsc

    Optional on the Experienced track

    tsconfig, build vs watch, and how editors surface errors as you type.

  3. 3. Type real application data confidently.

    Everyday Types

    Type real application data confidently.

    Time: about 1-2 weeks. Topics: Objects, interfaces & aliases · Unions & literal types · Arrays, tuples & enums · Functions as types.

    Objects, interfaces & aliases

    Shaping data with interface and type, optional/readonly members, extending and intersections.

    Unions & literal types

    Modelling real states ('loading' | 'error' | 'success') so invalid states can't compile.

    Arrays, tuples & enums

    Typed collections, fixed-shape tuples, and why const objects often beat enums.

    Functions as types

    Call signatures, optional params, overloads and typing callbacks.

  4. 4. Let the compiler prove your code safe.

    Narrowing & Guards

    Let the compiler prove your code safe.

    Time: about 1-2 weeks. Topics: Control-flow narrowing · Discriminated unions · Type predicates & assertions · unknown vs any.

    Control-flow narrowing

    typeof, in, instanceof and truthiness checks - how TS follows your ifs and narrows types with you.

    Discriminated unions

    A shared literal tag turns unions into exhaustive switch statements the compiler audits for you.

    Type predicates & assertions

    Custom guards (x is Fish), as-casts and never - and why every assertion is a small IOU.

    unknown vs any

    unknown forces proof before use; any turns the checker off. Learning to prefer the former is the TS growth moment.

  5. 5. Reusable code that stays type-safe.

    Generics & Advanced Types

    Reusable code that stays type-safe.

    Time: about 2 weeks. Topics: Generic functions & types · Utility types · keyof, typeof & indexed access · Mapped & conditional types (reading level).

    Generic functions & types

    Type parameters and constraints (extends) - writing once for many types without losing safety.

    Utility types

    Partial, Pick, Omit, Record, ReturnType, Awaited - the standard library of type transformations.

    keyof, typeof & indexed access

    Deriving types from values and objects - one source of truth instead of parallel definitions.

    Mapped & conditional types (reading level)

    Enough to read library types and error messages without fear - writing them comes later.

  6. 6. Use TS the way teams do.

    TS in Real Projects

    Use TS the way teams do.

    Time: about 2 weeks. Topics: strict mode · Typing React · Declaration files & libraries · Validating at the boundary.

    Build: Migrate a JS project to strict TS. Convert a small JS app to strict-mode TypeScript - the fastest way to internalise the system.

    strict mode

    strictNullChecks and friends - the flags that make TS worth using, on from day one.

    Typing React

    Props, state, events, children and generic components - typed UI end to end.

    Declaration files & libraries

    Reading .d.ts, @types packages and typing untyped dependencies.

    Validating at the boundary

    Runtime validation (e.g. zod) where data enters - types checked at compile time, data checked at runtime.

  7. 7. Verified proof of TS fluency.

Prove it as you go

Reading is half of it. This roadmap is backed by a free, scored TypeScript certification with a public verification link and a Frontend Engineer job simulation on real tickets - evidence a recruiter can check, not a claim. Mark topics done, learning or skipped as you go; your progress carries into the classic view.

Fresher or experienced?

Both tracks hold every topic. On the Fresher track the foundations are filled and the later stages are outlined - do them when a project needs them. On the Experienced track the foundations are outlined and the later stages are filled. The 2026 section at the top applies to both.

Prefer a list?

The classic view shows the same 6 stages as a sequential checklist with time estimates. Your marks are shared between the two views.

Frequently asked questions

Why learn TypeScript if I know JavaScript?

Because it is how new web code is written in 2026: GitHub's Octoverse 2025 found TypeScript overtook Python and JavaScript as the most used language on GitHub, as AI coding tools emit typed code by default and teams keep it because the compiler catches what the tools got wrong. Every job description that said JavaScript now says TypeScript first.

Is TypeScript hard to learn?

The basics are a weekend if you know JavaScript; the parts that take practice are generics, narrowing, utility types and the discipline of typing boundaries instead of casting. Strict mode is the teacher - leave it on from the first project and the compiler's errors become the curriculum.

Should I learn React or Node with TypeScript first?

Whichever matches the job you want, but learn TypeScript inside one of them rather than in isolation: typing props, state and hooks in React, or requests, responses and database rows in Node. Sharing one schema across the front and back ends is the skill that makes full stack TypeScript valuable.

Does using any defeat the point?

Mostly, yes. An any turns off the compiler for everything it touches, and AI tools reach for it whenever a type gets inconvenient. Learn unknown, narrowing and generics so that you have better tools, and treat every any in a codebase as a comment that says I gave up here.

How long does it take to become job-ready?

For someone who already writes JavaScript, weeks to be productive and a few months to be fluent with generics and typed boundaries; for a beginner, add the JavaScript roadmap first. Nobody can promise a timeline. The evidence is a deployed typed project whose types explain the design, and a certification a reviewer can verify.

Do I need to learn the compiler and build configuration?

Enough to read a configuration file, understand strict mode and target settings, and fix a build when it breaks. Most projects now use a framework or a tool that sets it up; Next.js, Vite and the AI builders all come typed. Deep compiler knowledge is a specialism for tooling roles.

Will AI write all the TypeScript anyway?

AI writes the first draft of most TypeScript now, and that is why the type system matters: it is the fastest way to review generated code. A widened type, a cast that hides a runtime shape, an optional never handled - the compiler points at each, if you know what you are looking at. The engineer who can read a generated signature and see the hole in it is the one teams hire.

How do I prove TypeScript skills without job experience?

A repository where the types do work: a typed client generated from an API's documentation, a full stack app sharing one schema between server and client, a published package with a typed interface and tests. Add a readme that explains the types as design choices, a note on what the AI tool typed loosely and what you tightened, and OneRoadmap's free TypeScript certification with its public link.