JavaScript

Hard

Skills

Language

Fundamentals

CO RE

14 skills

The

parts

JavaScript

that

not

change

between

frameworks

—

scope

types

objects

and

the

prototype

model

Asynchronous

JavaScript

the

Runtime

CO RE

9 skills

How

JavaScript

schedules

work

—

the

single

most

common

source

production

bugs

front

end

and

Node

codebases

2015+

syntax

—

let

const

arrow

functions

template

literals

default

rest

parameters

Data

types

coercion

—

primitives

objects

==/===

rules

truthiness

NaN

handling

Closures

lexical

scope

—

scope

chains

IIFEs

module

encapsulation

Hoisting

temporal

dead

zone

Prototypal

inheritance

—

prototype

chain

Object.create

class

syntax

this

binding

—

call

apply

bind

arrow

function

capture

Destructuring

spread

rest

—

object

and

array

patterns

shallow

cloning

Modules

—

ESM

import

export

dynamic

import

CommonJS

interop

Iterators

generators

—

Symbol

iterator

function

lazy

sequences

Collections

—

Map

Set

WeakMap

WeakSet

BigInt

Metaprogramming

—

Proxy

Reflect

property

descriptors

Symbol

keys

Functional

programming

—

pure

functions

currying

composition

immutability

Regular

expressions

—

flags

groups

lookahead

named

captures

Error

handling

—

try

catch

finally

custom

error

classes

error

boundaries

async

code

Event

loop

internals

—

call

stack

macrotask

queue

microtask

queue

rendering

steps

Callbacks

callback

patterns

—

error

first

convention

callback

hell

refactors

Promises

—

chaining

all

allSettled

race

any

finally

async

await

—

sequential

parallel

awaits

error

propagation

top

level

await

Async

iteration

—

for

await

...

async

generators

async

iterators

Cancellation

—

AbortController

AbortSignal

timeout

cleanup

unmount

Web

Workers

worker

threads

—

structured

clone

message

passing

off

main

thread

compute

Streams

—

ReadableStream

WritableStream

TransformStream

backpressure

Rate

control

—

debounce

throttle

request

batching

retry

with

exponential

backoff

1 / 6

DOM

Browser

APIs

the

Web

Platform

CO RE

11 skills

TypeScript

ADVANCED

9 skills

Front

End

Frameworks

Libraries

S PECIALIS T

15 skills

DOM

traversal

manipulation

—

querySelector

createElement

DocumentFragment

batch

updates

Event

model

—

bubbling

capturing

delegation

passive

listeners

pointer

events

Fetch

API

—

Request

Response

headers

streaming

bodies

abort

signals

Client

side

storage

—

localStorage

sessionStorage

IndexedDB

Cache

API

History

routing

APIs

—

pushState

popstate

URL

URLSearchParams

Observer

APIs

—

IntersectionObserver

ResizeObserver

MutationObserver

Realtime

transport

—

WebSockets

Server

Sent

Events

WebRTC

data

channels

Service

Workers

PWA

—

offline

caching

background

sync

push

notifications

manifests

Web

Components

—

Custom

Elements

Shadow

DOM

HTML

templates

slots

Graphics

media

—

Canvas

inline

SVG

WebGL

WebGPU

basics

MediaStream

File

API

Device

APIs

—

Geolocation

Clipboard

Notifications

Drag

Drop

Fullscreen

Type

annotations

inference

—

interfaces

type

aliases

readonly

optional

members

Generics

—

generic

constraints

default

type

params

generic

inference

patterns

Union

intersection

types

—

discriminated

unions

exhaustive

switch

checks

Narrowing

type

guards

—

typeof

instanceof

user

defined

predicates

assertion

functions

Utility

types

—

Partial

Required

Pick

Omit

Record

Readonly

ReturnType

Awaited

Advanced

type

construction

—

mapped

types

conditional

types

template

literal

types

infer

Declaration

files

—

authoring

ambient

modules

module

augmentation

Compiler

configuration

—

tsconfig

strict

mode

target

module

resolution

path

aliases

Decorators

enums

—

legacy

and

Stage

decorators

const

enums

namespaces

React

—

hooks

context

memoization

Suspense

error

boundaries

React

Server

Components

—

server

client

boundaries

streaming

actions

—

App

Router

SSR

SSG

ISR

route

handlers

middleware

image

optimization

Vue

—

Composition

API

reactive

refs

custom

directives

transitions

Nuxt

—

file

based

routing

server

routes

auto

imports

hybrid

rendering

Angular

—

standalone

components

signals

dependency

injection

RxJS

integration

Svelte

SvelteKit

—

compiled

reactivity

stores

load

functions

form

actions

SolidJS

Astro

Qwik

—

fine

grained

reactivity

islands

architecture

resumability

State

management

—

Redux

Toolkit

Zustand

MobX

Pinia

Jotai

Server

state

caching

—

TanStack

Query

SWR

Apollo

Client

cache

policies

Routing

—

React

Router

TanStack

Router

Vue

Router

nested

lazy

routes

Styling

systems

—

Tailwind

CSS

Modules

styled

components

Sass

Component

libraries

—

MUI

Chakra

Radix

shadcn

Ant

Design

Form

handling

—

React

Hook

Form

Formik

Zod

Yup

resolvers

validation

Data

visualization

—

Recharts

Chart

Three

visx

2 / 6

Node

Server

Side

JavaScript

ADVANCED

13 skills

Build

Bundling

Developer

Tooling

ADVANCED

9 skills

Testing

Code

Quality

CO RE

9 skills

Node

runtime

model

—

module

resolution

event

loop

phases

process

Buffer

APIs

Package

management

—

npm

pnpm

Yarn

semver

ranges

lockfiles

workspaces

HTTP

frameworks

—

Express

Fastify

Koa

NestJS

Hapi

REST

API

design

—

resource

modeling

status

codes

pagination

versioning

HATEOAS

basics

GraphQL

—

schema

design

resolvers

Apollo

Server

GraphQL

Yoga

mitigation

tRPC

end

type

safety

Realtime

servers

—

Socket

pub

sub

fan

out

presence

tracking

ORM

ODM

—

Prisma

Drizzle

Mongoose

Sequelize

Knex

Authentication

authorization

—

JWT

OAuth

2.0,

OIDC

session

RBAC

Passport

Schema

validation

—

Zod

Joi

Yup

Ajv

request

response

contracts

Background

jobs

—

BullMQ

agenda

cron

scheduling

idempotent

workers

File

stream

handling

—

multer

signed

uploads

piping

object

storage

Process

management

—

clustering

graceful

shutdown

health

checks

Bundlers

—

Vite

Webpack

Rollup

esbuild

Parcel

Turbopack

Transpilation

—

Babel

SWC

TypeScript

compiler

browser

targets

Linting

formatting

—

ESLint

Prettier

Biome

Stylelint

shared

configs

CSS

pipelines

—

PostCSS

autoprefixer

Sass

Tailwind

content

scanning

Monorepo

tooling

—

Turborepo

pnpm

workspaces

package

boundaries

Environment

configuration

—

env

files

runtime

config

injection

secret

handling

Optimization

—

tree

shaking

minification

code

splitting

source

maps

Task

runners

scripts

—

npm

scripts

concurrently

watch

mode

pre

commit

hooks

Dev

environments

—

Dev

Containers

Docker

Compose

local

HTTPS

proxy

setup

Unit

testing

—

Jest

Vitest

Mocha

Chai

test

structure

and

fixtures

Component

testing

—

React

Testing

Library

Vue

Test

Utils

user

event

End

end

testing

—

Playwright

Cypress

Puppeteer

Selenium

API

integration

testing

—

Supertest

Postman

Newman

contract

tests

Mocking

interception

—

MSW

Sinon

jest

mock

fake

timers

Coverage

tooling

—

Istanbul

nyc

coverage

thresholds

Component

documentation

—

Storybook

visual

regression

with

Chromatic

Load

performance

testing

—

Artillery

Lighthouse

budgets

Test

strategy

—

test

pyramid

TDD

snapshot

assertion

flake

triage

3 / 6

Performance

Engineering

ADVANCED

9 skills

Data

APIs

Integration

ADVANCED

7 skills

Databases

Persistence

S PECIALIS T

6 skills

Architecture

Design

Patterns

ADVANCED

9 skills

Core

Web

Vitals

—

LCP

INP

CLS

TTFB

field

lab

data

Code

splitting

lazy

—

dynamic

import

route

level

chunks

prefetching

Runtime

optimization

—

memoization

avoiding

layout

thrash

virtualized

lists

Bundle

analysis

—

webpack

bundle

analyzer

rollup

plugin

visualizer

dependency

budgets

Caching

strategy

—

HTTP

cache

headers

ETags

CDN

edge

cache

stale

while

revalidate

Rendering

strategies

—

CSR

SSR

SSG

ISR

streaming

HTML

partial

hydration

Asset

optimization

—

responsive

images

AVIF

WebP

font

subsetting

preload

preconnect

Profiling

—

Chrome

DevTools

Performance

Memory

panels

heap

snapshots

flame

charts

Monitoring

—

Lighthouse

WebPageTest

RUM

instrumentation

performance

budgets

Protocols

—

REST

GraphQL

gRPC

Web

WebSockets

SSE

HTTP

/2 &

HTTP

basics

Serialization

formats

—

JSON

YAML

XML

Protocol

Buffers

schema

evolution

HTTP

clients

—

fetch

axios

got

TanStack

Query

wrappers

API

specification

—

OpenAPI

Swagger

schema

first

code

generation

SDK

publishing

Caching

layers

—

Redis

edge

caching

ETags

client

side

request

duplication

Resilience

patterns

—

retries

with

jitter

circuit

breakers

rate

limiting

idempotency

keys

Third

party

integrations

—

payments

auth

providers

analytics

CRM

and

messaging

APIs

Relational

databases

—

PostgreSQL

MySQL

SQLite

joins

indexes

transactions

Document

wide

column

stores

—

MongoDB

DynamoDB

Firestore

aggregation

pipelines

Key

value

caches

—

Redis

Memcached

TTL

design

cache

invalidation

Schema

migration

—

Prisma

Migrate

Knex

migrations

Flyway

zero

downtime

deploys

Data

modeling

—

normalization

denormalization

trade

offs

index

strategy

detection

—

PostgreSQL

full

text

Elasticsearch

Meilisearch

ranking

basics

Modular

design

—

separation

concerns

layering

dependency

direction

Classic

patterns

—

observer

pub

sub

factory

singleton

strategy

decorator

adapter

Application

architectures

—

MVC

MVVM

Flux

Redux

unidirectional

data

flow

Dependency

injection

—

constructor

injection

inversion

control

containers

Event

driven

design

—

event

sourcing

basics

message

contracts

CQRS

concepts

Micro

frontends

—

module

federation

shell

remote

composition

shared

design

tokens

Design

systems

—

token

architecture

headless

components

component

APIs

Refactoring

legacy

migration

—

strangler

pattern

codemods

incremental

TypeScript

adoption

Technical

documentation

—

JSDoc

TypeDoc

ADRs

RFC

authoring

4 / 6

Security

ADVANCED

9 skills

DevOps

Cloud

Observability

S PECIALIS T

10 skills

Accessibility

Internationalization

CO RE

8 skills

Cross

site

scripting

(

XSS

)

prevention

—

output

encoding

escaping

safe

DOM

sinks

Input

sanitization

—

DOMPurify

validation

schemas

allow

list

parsing

CSRF

protection

—

CSRF

tokens

SameSite

origin

checks

Content

Security

Policy

—

nonces

hashes

reporting

endpoints

CORS

configuration

—

preflight

handling

credentialed

requests

origin

allow

lists

OWASP

Top

for

web

applications

Authentication

hardening

—

token

storage

refresh

rotation

PKCE

secure

flags

Dependency

security

—

npm

audit

Snyk

Dependabot

SBOM

awareness

Transport

integrity

—

HTTPS

TLS

HSTS

Subresource

Integrity

Version

control

—

Git

branching

models

rebase

merge

conventional

commits

Code

review

practice

—

GitHub

GitLab

workflows

review

checklists

protected

branches

pipelines

—

GitHub

Actions

GitLab

CircleCI

Jenkins

Containers

—

Dockerfile

authoring

multi

stage

builds

Docker

Compose

Serverless

edge

—

AWS

Lambda

Cloudflare

Workers

Vercel

Edge

Functions

Cloud

platforms

—

AWS

(

CloudFront

API

Gateway

Vercel

Netlify

GCP

basics

Infrastructure

code

—

Terraform

fundamentals

Serverless

Framework

CDK

concepts

Error

tracking

—

Sentry

Rollbar

source

map

upload

release

tagging

Logging

metrics

tracing

—

structured

logs

OpenTelemetry

dashboards

and

alerts

Release

strategies

—

blue

green

canary

feature

flags

rollback

procedures

WCAG

2.2

conformance

—

perceivable

operable

understandable

robust

criteria

Semantic

HTML

—

landmarks

heading

order

native

controls

over

divs

ARIA

—

roles

states

properties

live

regions

correct

usage

limits

Keyboard

focus

management

—

focus

trapping

roving

tabindex

skip

links

Screen

reader

testing

—

NVDA

JAWS

VoiceOver

TalkBack

workflows

Automated

audits

—

axe

Lighthouse

accessibility

gates

Internationalization

—

react

intl

ICU

message

format

pluralization

Locale

aware

formatting

—

Intl

DateTimeFormat

NumberFormat

Collator

RTL

layout

support

5 / 6

Workflow

Debugging

Collaboration

CO RE

8 skills

Domain

Summary

190+ skills

DOMAIN

LEVEL

SKILLS

Language

Fundamentals

Core

Asynchronous

JavaScript

the

Runtime

Core

DOM

Browser

APIs

the

Web

Platform

Core

TypeScript

Advanced

Front

End

Frameworks

Libraries

Specialist

Node

Server

Side

JavaScript

Advanced

Build

Bundling

Developer

Tooling

Advanced

Testing

Code

Quality

Core

Performance

Engineering

Advanced

Data

APIs

Integration

Advanced

Databases

Persistence

Specialist

Architecture

Design

Patterns

Advanced

Security

Advanced

DevOps

Cloud

Observability

Specialist

Accessibility

Internationalization

Core

Workflow

Debugging

Collaboration

Core

Browser

DevTools

—

Elements

Network

Sources

Performance

Application

panels

Debugging

technique

—

breakpoints

watch

expressions

call

stack

reading

source

maps

Editor

configuration

—

Code

extensions

workspace

settings

snippets

tasks

Design

handoff

—

Figma

inspection

design

tokens

spec

code

translation

Agile

delivery

—

sprint

planning

story

estimation

Linear

Jira

ticket

hygiene

Incident

response

—

triage

postmortems

blameless

retrospectives

runbooks

Technical

writing

—

READMEs

API

docs

changelogs

migration

guides

Mentorship

knowledge

sharing

—

pairing

internal

talks

onboarding

documentation

6 / 6

JavaScript Hard Skills

Prompt to Clone This JavaScript Hard Skills

Apply this example's core structure, strategic pacing, and structural hierarchy directly to your own topic.

What are you generating today?

Accounts Receivable Hard Skills

Cost Accounting Hard Skills

Investment Analysis Hard Skills

Search Engine Optimization Hard Skills

Search Engine Marketing Hard Skills

Google Analytics Hard Skills

Email Marketing Hard Skills

Content Marketing Hard Skills

Marketing Automation Hard Skills

Market Research Hard Skills

Sales Forecasting Hard Skills

Lead Generation Hard Skills

Customer Relationship Management Hard Skills

Similar Examples