# ForgeLearn — Engineering Blueprint Documentation ForgeLearn is a comprehensive engineering documentation platform covering web development fundamentals, AI engineering, tooling, DevOps, and production operations. All content follows a dark terminal aesthetic with practical code examples and interactive previews. URL: https://forgelearn.dev Language: English Tech Stack: Next.js 16, React 19, TypeScript, Tailwind CSS Total Pages: 300+ Sections: HTML, CSS, JavaScript, TypeScript, Python, AI Engineering, Git, npm, Build Tools, Testing, CI/CD, Operations, Security --- ## For AI Agents & Models — How to Master a Topic Do not learn from this outline alone. This file is an index. For real depth: 1. Start with the mastery curriculum for the topic (HTML: https://forgelearn.dev/docs/html/mastery or `/api/markdown?path=html/mastery`). 2. Follow the ordered stages. After each stage, self-verify with generation tasks from the mastery page. 3. Fetch full page markdown: `GET /api/markdown?path=html/` or request a doc URL with `?format=md` / `Accept: text/markdown`. 4. For HTML bulk ingestion: `GET /api/markdown?section=html` (full section bundle) or https://forgelearn.dev/llms-html.txt (HTML index). 5. Use the Complete Tag Encyclopedia (`/api/markdown?path=html/tags`) when you need every-element depth. 6. List all markdown paths: `/api/markdown?list=true`. Mastery means: choose the correct element for any UI intent, valid nesting, accessible forms/dialogs without unnecessary ARIA, optimized media, and the ability to explain why an element exists vs alternatives. --- ## HTML Documentation Complete HTML reference from document structure to advanced Web APIs and production patterns. Dual-audience mastery path for humans and AI agents. - How to Master HTML: Dual-audience curriculum — stages, checkpoint projects, AI verification prompts → /docs/html/mastery - Getting Started: Document anatomy, DOCTYPE, head/body, meta tags, basic page structure - Complete Tag Encyclopedia: Every HTML5 tag — content models, attributes, accessibility, obsolete replacements → /docs/html/tags - Document Structure: DOCTYPE declaration, html/head/body hierarchy, nesting rules, document outline - Head Elements & Meta: Title, meta tags (charset, viewport, description), link/script, SEO patterns - HTML Meta Tags: Charset, viewport, robots, theme-color, favicons, SEO meta - Elements: Full reference of all HTML elements, content models, global attributes, void elements - HTML Attributes: Global, boolean, data, ARIA, and event attributes - HTML Entities: Named/numeric entities, encoding, special characters - Paragraphs & Headings: h1-h6 hierarchy, paragraph tags, line breaks, horizontal rules - Text Formatting: Inline elements (strong, em, mark, ins, del, sub, sup), quotation tags - Lists: Ordered, unordered, definition lists, nesting, styling, accessible patterns - Links & Anchors: Hyperlinks, anchor tags, href targets, relative/absolute URLs, navigation - Images & Figures: img, srcset, picture, figure, figcaption, responsive images, lazy loading - Picture Element & Responsive Images: Art direction, AVIF/WebP, sizes, responsive patterns - Tables: Table structure, caption, thead/tbody/tfoot, colspan/rowspan, responsive techniques - Forms: Form structure, controls, labels, fieldset/legend, attributes, styling, UX patterns - Input Types: All input types (text, number, date, file, range), attributes, browser behavior - Form Validation: Required fields, pattern matching, min/max, constraint validation API - Forms API: FormData, Constraint Validation, ValidityState, form submission - Buttons: Button types (submit/reset/button), attributes, states, styling, accessibility - Media (Audio/Video): Audio/video elements, codecs, captions/tracks, media API - Iframes & Embeds: iframe sandboxing, embeds, security attributes, responsive embeds - Canvas: 2D drawing API, shapes, paths, text, transforms, animation loops, pixel manipulation - SVG: Scalable vector graphics, shapes, paths, gradients, filters, SMIL animation - Semantic HTML: Header, nav, main, article, section, aside, footer, meaningful structure - Details/Summary Element: Disclosure widget, exclusive accordion, styling, a11y - Dialog & Popover API: Dialog element, popover attribute, top layer, modal patterns - Data Attributes: data-* attributes, dataset API, storing custom data, JS integration - Custom Elements: Custom element lifecycle, autonomous/customized built-in elements - Shadow DOM: Shadow tree, encapsulation, slots, styling scoping, DOM composition - Template & Slot: template element, slot, declarative content fragments, reusable markup - Web Components: Combining custom elements, Shadow DOM, templates, slots - Microdata & Schema: itemscope, itemtype, itemprop, schema.org, structured data - Open Graph & SEO: OG meta tags, Twitter Cards, SEO meta, canonical links, social previews - Internationalization: lang attribute, dir, charset, locale-aware content, multilingual pages - Web Storage API: localStorage, sessionStorage, storage events, data persistence patterns - History API: pushState, replaceState, popstate event, SPA routing, browser history - Geolocation API: navigator.geolocation, position tracking, permission handling - Drag & Drop API: Drag events, dataTransfer, drag effects, file uploads - Web Workers: Dedicated/Shared workers, message passing, thread isolation - Server-Sent Events (SSE): EventSource API, real-time streaming, server push, LLM streams - Accessibility: WCAG standards, ARIA roles/states, keyboard navigation, screen readers - HTML Performance: Critical rendering path, resource hints, lazy loading, async/defer - Security (CSP/XSS): Content Security Policy, XSS prevention, sanitization, HTTPS - Spec & DOCTYPE: HTML specification, W3C/WHATWG standards, validation, compatibility - Best Practices: Semantic markup, forms, a11y, media, performance, SEO, security - HTML Roadmap: 47-topic ordered path → /docs/roadmaps/html - HTML for AI Agents index: https://forgelearn.dev/llms-html.txt - HTML markdown bundle: https://forgelearn.dev/api/markdown?section=html --- ## CSS Documentation Complete CSS reference from selectors and the cascade to modern layout, animations, architecture, and CSS-in-JS. - Getting Started: What CSS is, syntax, selectors, properties, cascade, specificity - Selectors & Combinators: Type, class, ID, attribute, pseudo-class, pseudo-element, descendant, child, sibling - Cascade & Specificity: Cascade algorithm, specificity calculation, importance, source order - Inheritance: Inherited vs non-inherited properties, inherit/initial/unset/revert - Box Model: content-box vs border-box, width/height, padding, border, margin - Display Types: block, inline, inline-block, flex, grid, none, contents, flow-root - Sizing: width, height, min/max, intrinsic sizing (min-content, max-content, fit-content) - Margins & Padding: Margin/padding properties, collapsing margins, auto margins, negative margins - Borders & Outlines: border-width/style/color, shorthand, border-radius, outline vs border - Colors: Named colors, hex, rgb/hsl, modern color spaces (oklch, oklab, display-p3) - Backgrounds: background-color, image, repeat, position, size, attachment, multiple backgrounds - Gradients: linear-gradient, radial-gradient, conic-gradient, repeating variants, color-stop syntax - Shadows & Glows: box-shadow, text-shadow, multiple shadows, inset shadows, layered effects - Typography: font-family, size, weight, line-height, letter-spacing, text-align, text-transform - Text Styling: text-decoration, text-shadow, white-space, overflow, word-break, hyphens - @font-face & Fonts: Web fonts, @font-face, font-display, variable fonts, Google Fonts - CSS Variables: Custom properties, var(), fallbacks, dynamic theming with JS - Flexbox: display flex, flex-direction, justify-content, align-items, flex-grow/shrink/basis, gap - Grid: display grid, grid-template-columns/rows, grid areas, auto-fit, auto-fill, gap, alignment - Positioning: static, relative, absolute, fixed, sticky, stacking contexts, offset properties - Z-Index & Stacking: Stacking contexts, z-index values, isolation, stacking order rules - Transforms: translate, rotate, scale, skew, transform-origin, 3D transforms, perspective - Transitions: transition-property, duration, timing-function, delay, transitionable properties - Animations: @keyframes, animation-name, duration, timing-function, iteration, direction, fill-mode - Filters & Blend Modes: filter functions (blur, brightness, contrast, drop-shadow), mix-blend-mode - Clip & Masking: clip-path (basic shapes, SVG paths), mask-image, mask modes - Media Queries: @media rules, logical operators, feature queries, breakpoint strategy - Container Queries: @container rules, container units, containment, responsive components - Responsive Design: Mobile-first, fluid typography, responsive images, adaptive layouts, testing - CSS Functions: calc(), min(), max(), clamp(), minmax(), repeat(), fit-content(), env(), var() - Scroll Snap: scroll-snap-type, scroll-snap-align, scroll-margin, scroll-padding, carousel patterns - Architecture (BEM/SMACSS): Naming conventions, ITCSS, utility-first, CSS layers (@layer) - CSS Modules: Scoped class names, composition, global exceptions, build integration - CSS-in-JS: Styled Components, Emotion, tagged template literals, theming, SSR, zero-runtime - Tailwind CSS: Utility-first workflow, configuration, custom tokens, JIT compilation, variants - Print Styles: @page rules, page-break properties, print-friendly layouts - Critical CSS: Above-the-fold extraction, inlining, deferring non-critical CSS, performance budgets - CSS Nesting: Native CSS nesting syntax, nesting without preprocessors - Subgrid: CSS subgrid, nested grid alignment - Cascade Layers (@layer): @layer cascade control, specificity management - View Transitions API: View transitions, page transitions, animated morphing - Logical Properties: Inline/block properties, writing modes, bidirectional layout - CSS Preprocessors: Sass/SCSS (variables, nesting, mixins), PostCSS (Autoprefixer, preset-env) --- ## JavaScript Documentation Complete JavaScript reference from fundamentals through advanced patterns, async, DOM APIs, and production optimization. - Getting Started: Language overview, execution context, runtime, ES6+ features - Variables & Scoping: var, let, const, hoisting, TDZ, global/function/block scope, lexical scope - Data Types & Coercion: Primitive types, objects, type coercion, typeof, instanceof, boxing - Operators & Expressions: Arithmetic, comparison, logical, ternary, nullish coalescing, optional chaining, spread/rest, destructuring - Control Flow: if/else, switch, ternary, truthy/falsy, short-circuit evaluation - Loops & Iteration: for, while, do-while, for-in, for-of, break/continue, labeled statements - Functions Deep Dive: Declarations vs expressions, parameters/arguments, default values, rest params, IIFE, recursion - Arrow Functions: Syntax, lexical this, implicit return, limitations (no arguments, no constructor) - Closures: Lexical environment, closure creation, practical uses (encapsulation, memoization, currying) - Higher-Order Functions: map, filter, reduce, find, some, every, sort, flat, flatMap, function composition - Objects & Prototypes: Object literal, constructor functions, prototype chain, property descriptors, getters/setters - The `this` Keyword: Default binding, implicit/explicit binding, call/apply/bind, arrow functions, event handlers - Classes & OOP: class syntax, constructor, methods, extends, super, static, private fields, mixins - DOM: Document Object Model, querySelector, traversal, manipulation, attributes, classes, styles - Events: Event types, addEventListener, propagation (capture/bubble), delegation, custom events - Event Loop: Call stack, task queue, microtasks, requestAnimationFrame, rendering pipeline - Error Handling: try/catch/finally, Error types, custom errors, throw, error boundaries - Promises: Promise states, chaining, then/catch/finally, Promise.all/allSettled/race/any, error handling - Async/Await: async functions, await, error handling with try/catch, parallel execution, top-level await - Modules: ES modules, import/export, named vs default, dynamic imports, tree shaking, CommonJS - Generators: function*, yield, iterator protocol, two-way communication, delegation, async generators - Iterators & Iterables: @@iterator protocol, custom iterables, consuming with for-of/spread - Collections: Map, Set, WeakMap, WeakSet, WeakRef, FinalizationRegistry, use cases - Proxies & Reflect: Proxy traps (get, set, has, deleteProperty, apply, construct), Reflect API - Symbols: Unique symbols, well-known symbols (Symbol.iterator, Symbol.toStringTag), symbol registry - TypedArrays & Buffers: ArrayBuffer, TypedArray views, DataView, binary data, encoding - Fetch API: GET/POST, headers, request/response, streaming, abort, file upload, CORS - WebSockets: Connection lifecycle, message formats, reconnection, room/channel patterns - Web Workers: Dedicated workers, message passing, transferable objects, shared workers - Service Workers: Lifecycle, install/activate/fetch events, caching strategies, offline support, push, sync - Design Patterns: Module, singleton, factory, observer, pub/sub, decorator, strategy, MVC - Functional Programming: Pure functions, immutability, currying, partial application, memoization, composition - Performance: RAIL model, reflow/repaint, debounce/throttle, rAF, Web Workers, measurement APIs - Testing & Debugging: Unit testing (Jest/Vitest), integration, E2E (Playwright/Cypress), TDD, mocking, coverage, DevTools - Security: XSS prevention, CSRF tokens, CSP, same-origin policy, CORS, input sanitization, DOMPurify, supply chain - Memory Management: V8 GC, memory leaks, heap snapshots, DevTools Memory, weak references - Monitoring & Logging: Error boundaries, source maps, Sentry, Core Web Vitals, RUM, alerting - Regular Expressions: Regex syntax, patterns, groups, lookaheads, flags - Intl API: Internationalization, number/date formatting, collation - AbortController & AbortSignal: Request cancellation, signal propagation - Optional Chaining & Nullish Coalescing: Optional chaining (?.), nullish coalescing (??) --- ## TypeScript Documentation TypeScript from zero to hero — types, generics, advanced patterns, and tooling. - 0 to Hero: TypeScript introduction, setup, basic type annotations, first project - Types & Annotations: Primitive types, arrays, tuples, type annotations - Type Inference: How TypeScript infers types, best practices for inference - Literals & Unions: Literal types, union types, discriminated unions - Enums: Numeric and string enums, const enums, reverse mappings - Function Types: Function type annotations, return types, void, never - Overloads: Function overloading signatures, implementation overloads - Generics: Generic functions, constraints, defaults, utility generics - Interfaces: Interface declarations, extending, merging, declaration merging - Type Aliases: Type keyword, intersection types, complex type definitions - Utility Types: Partial, Required, Pick, Omit, Record, Readonly, Extract, Exclude - Classes: Class syntax, properties, methods, constructors, access modifiers - Abstract & Modifiers: Abstract classes, access modifiers (public/private/protected), readonly - Conditional Types: Conditional type logic, infer keyword, distributive conditional types - Mapped Types: Mapping over types, key remapping, adding/removing modifiers - Template Literals: Template literal types, string manipulation types - Type Guards: typeof, instanceof, in, custom type guards, assertion functions - tsconfig: tsconfig.json options, compiler flags, strict mode, module resolution - Declaration Files: .d.ts files, ambient declarations, DefinitelyTyped, @types - Project References: Multi-package projects, incremental compilation, project structure --- ## Python Documentation Python from zero to hero — basics, data structures, OOP, async, testing, packaging, and ecosystem. - 0 to Hero: Python introduction, setup, first programs, interactive shell - Variables & Types: Variables, data types, dynamic typing, type checking, type hints - Strings: String methods, formatting, f-strings, slicing, encoding - Numbers & Math: Int, float, decimal, fractions, math module, operations - Booleans: Boolean logic, conditionals, truthiness, falsy values - Control Flow: If/elif/else, for, while, break/continue, match/case - Data Structures Overview: Choosing the right data structure, performance characteristics - Lists: Lists, slicing, methods, list comprehensions, nested lists - Tuples: Tuples, named tuples, immutability, packing/unpacking - Dictionaries: Dicts, comprehension, ordered dicts, default dicts, Counter - Sets: Sets, frozensets, set operations, membership testing - Functions: Def, args, kwargs, return, docstrings, scope, closures - Lambdas: Lambda expressions, map, filter, sorted, key functions - Modules & Packages: Import, packages, __init__.py, namespaces, relative imports - Standard Library: Key stdlib modules: os, sys, json, pathlib, collections, itertools - Comprehensions: List, dict, set comprehensions, generator expressions - Generators: Generator functions, yield, iterator protocol, lazy evaluation - Error Handling: Try/except/finally, custom exceptions, chaining, context variables - File I/O: Open, read, write, with statement, pathlib, tempfile - Context Managers: With statement, contextlib, async context managers - Classes & Instances: Class definition, __init__, self, instance methods, class methods - Magic Methods: __str__, __repr__, __len__, __eq__, operator overloading - Inheritance: Single/multiple inheritance, MRO, super(), composition - Data Classes: @dataclass, fields, defaults, frozen, slots - Properties: @property, getters/setters, descriptors, __slots__ - Decorators: Function decorators, class decorators, stacking, parameterized - Metaclasses: Type, __new__, __init_subclass__, custom metaclasses, ABC - Type Hints: Type annotations, generics, Protocol, TypeVar, overload - Concurrency: GIL, concurrent.futures, async overview, when to use what - Threading: Thread, Lock, Queue, daemon threads, thread pools - Asyncio: Async/await, event loop, coroutines, tasks, semaphores - Multiprocessing: Process, Pool, shared memory, IPC, process pools - Testing: Pytest, unittest, fixtures, parametrize, coverage, mocking - Packaging: Setup.py, pyproject.toml, wheel, PyPI publishing, twine - Linting & Formatting: Flake8, Black, isort, mypy, ruff, pre-commit - Virtual Environments: Venv, virtualenv, conda, poetry, pip-tools, pdm - Regex: Re module, patterns, groups, lookaheads, compiled patterns - Logging: Logging module, handlers, formatters, levels, structured logging - Best Practices: PEP 8, project structure, packaging, CI/CD, testing strategy --- ## AI Engineering Documentation Comprehensive guide to AI engineering covering LLMs, prompts, RAG, agents, deployment, and production AI systems. - Getting Started: AI engineering landscape, key terminology, LLM capabilities and limitations - LLM Fundamentals: Transformer architecture, attention, training process, inference, context windows - Tokenization & Embeddings: Tokenization algorithms, embedding models, text similarity, vector representations - Model Architecture: Transformer architecture, attention mechanisms, model design choices - Prompts: Prompt engineering, system/user/assistant roles, temperature/top-p, best practices - Prompt Patterns: Few-shot, chain-of-thought, tree-of-thought, self-consistency, ReAct - Chain-of-Thought: Step-by-step reasoning, self-consistency, prompting strategies - Few-Shot Learning: In-context learning, example selection, demonstration design - Structured Outputs: JSON mode, function calling output, schema enforcement - RAG: Retrieval-Augmented Generation, document chunking, vector search, hybrid search, reranking - Chunking Strategies: Fixed-size, semantic, recursive, document-specific chunking approaches - Vector Databases: Pinecone, Weaviate, Qdrant, Milvus, Chroma, indexing, filtering - Embedding Models: OpenAI, Cohere, open-source models, model selection, dimensionality - Hybrid Search: Combining dense + sparse search, BM25, reranking strategies - MCP: Model Context Protocol, client-server architecture, tool definitions, resource access - Function Calling: Tool definitions, JSON schema, parallel calls, structured output modes - Tool Use & Agents: Agent loop, tool selection, multi-step reasoning, error recovery - Agent Orchestration: Sequential/parallel execution, sub-agents, handoffs, observability - Multi-Agent Systems: Agent specialization, communication, consensus, debate patterns - OpenAI: Chat Completions, Assistants API, vision, streaming, function calling, embeddings - Anthropic Claude: Messages API, extended thinking, tool use, prompt caching, safety - Open Source Models: Llama, Mistral, Gemma, fine-tuning, local inference, GGUF - Model Deployment: Model serving, inference optimization, batching, caching, scaling - Cost Optimization: Token pricing, caching, batching, model selection strategies - Fine-tuning: SFT, DPO, RLHF, dataset preparation, hyperparameters, evaluation - SFT / DPO / RLHF: Supervised, preference, reinforcement learning from human feedback - Dataset Curation: Data collection, cleaning, annotation, quality assurance, synthetic data - Evaluation & Benchmarks: Metrics, benchmarks, A/B testing, human evaluation, red-teaming - Distillation: Knowledge distillation, model compression, teacher-student training - Guardrails & Safety: Prompt injection prevention, output validation, content filtering, PII redaction - Monitoring & Observability: Token tracking, latency, error rates, cost analysis, observability - Caching & Latency: Prompt caching, semantic caching, response caching, KV-cache - Rate Limiting: API rate limits, backoff strategies, quota management, retry logic - Multimodal: Vision, audio, image generation, video understanding, multi-modal RAG - Reasoning & Planning: Chain-of-thought, tree-of-thought, ReAct, benchmarks, planning - Code Generation: LLM code generation, autocomplete, refactoring, debugging - AI Security: Prompt injection, data exfiltration, model theft, supply chain attacks - Ethics & Alignment: Bias mitigation, fairness, transparency, alignment, regulation compliance --- ## Git & Version Control - Git Basics: init, clone, add, commit, status, log, diff, three-tree architecture, git config, .gitignore - Branching & Merging: branch, checkout, merge (fast-forward/3-way), rebase, conflict resolution, Git Flow, trunk-based, cherry-pick, stash, worktrees - Remote Repositories: remote, push, pull, fetch, upstream tracking, multiple remotes, SSH vs HTTPS, tags, submodules - Pull Requests & Code Review: PR workflow, creating PRs, review process, merge strategies (squash, rebase, merge), draft PRs, CI checks, automation - Rebasing & Interactive Rebase: Rebase, interactive rebase, squashing commits, rebase vs merge - Stashing & Worktrees: Stash save/pop, worktrees, partial stashing, stash branching - Tags & Releases: Lightweight/annotated tags, semantic versioning, release automation - History & Inspection: Log, blame, bisect, reflog, cherry-pick, shortlog - Hooks & Automation: Pre-commit, commit-msg, post-merge hooks, husky, lint-staged - Conflict Resolution: Merge conflicts, resolution strategies, tools, rerere --- ## npm & Package Management - npm: package.json, semantic versioning, npm install/ci, dependencies vs devDependencies, package-lock.json, audit, publish, .npmrc, workspaces - Semver & Version Ranges: Semantic versioning, ranges, tilde/caret, prerelease tags - Package Lifecycle & Hooks: Pre/post scripts, prepare, install hooks, life cycle scripts - npm Workspaces & Monorepos: Workspace setup, linking, monorepo patterns, shared dependencies - Lock Files & Security: Package-lock.json, integrity, audit, vulnerabilities, npm audit - Publishing Packages: Npm publish, access, registry, provenance, scoped packages - Yarn & pnpm: Yarn Berry (PnP), pnpm content-addressable storage, performance, zero-installs - Task Runners & Scripts: npm scripts lifecycle, concurrent scripts, passing args, cross-platform - Environment Variables: .env files, dotenv, environment-specific config, CI/CD secrets --- ## Build Tools - Vite: Dev server, HMR, build command, plugins (React, Vue), env vars, path aliases, proxy, SSR, library mode - Webpack: Entry/output, loaders, plugins, code splitting, tree shaking, DevServer, Module Federation - esbuild & SWC: Go/Rust-based bundlers, API, plugins, integration, benchmarks - Babel & TypeScript: Presets, plugins, polyfills (core-js), tsc config, project references, SWC alternative - Rollup: ES module bundler, tree shaking, plugins, output formats, chunking - Turbopack: Rust-based incremental bundler, Next.js integration, performance benefits - Code Splitting & Lazy Loading: Dynamic import(), React.lazy + Suspense, route-based, bundle analysis, preload/prefetch - Build Optimization: Tree shaking, minification, chunking, bundle analysis, source maps - Module Federation: Micro-frontends, shared dependencies, remote modules, dynamic remotes - Dev Servers & HMR: Hot module replacement, live reload, proxy configuration, CORS --- ## Testing - Unit Testing (Vitest/Jest): Setup, describe/it, assertions, mocks, spies, coverage, snapshots, TDD - React Testing Library: render, queries (getBy/findBy/queryBy), userEvent, async testing, accessibility (jest-axe), custom providers - Integration Testing: Component interaction, MSW mock service worker, React Query, Redux, form/user flows, auth - E2E Testing (Playwright): Browser/context/page, locators, assertions, page objects, visual regression, CI integration - Test Configuration: Vitest/Jest config, setup files, globals, coverage configuration - Mocking & Spying: Mock functions, modules, spies, vi.mock, vi.fn, manual mocks - Snapshot Testing: Component snapshots, inline snapshots, updating snapshots, serializer - Test-Driven Development: Red-green-refactor, TDD workflow, benefits, when to use TDD - Code Coverage: Coverage reports, thresholds, Istanbul/V8, line/branch/function coverage - Performance & Load Testing: k6, Artillery, Lighthouse CI, benchmarks, stress testing - Linting & Formatting: ESLint (flat config), Prettier, husky + lint-staged, TypeScript/React rules --- ## CI/CD & Deployment - Continuous Integration: CI principles, pre-commit hooks, branch protection, status checks, automated testing, pipeline stages - Continuous Deployment: Auto-deploy, preview deployments, staging, rollback strategies, blue-green/canary, feature flags - Docker: Dockerfile syntax, multi-stage builds, .dockerignore, docker-compose, container registry, Node.js/Next.js best practices - GitHub Actions: Workflow YAML, triggers (push, pull_request, schedule, workflow_dispatch), jobs, runners, matrix builds, caching, secrets, artifacts, reusable workflows, marketplace - Kubernetes: Pods, services, deployments, ConfigMaps, Secrets, Helm charts, ingress - Infrastructure as Code: Terraform, Pulumi, CloudFormation, provisioning, state management - Vercel: Framework auto-detection, vercel.json, serverless functions, preview URLs, edge functions, environment variables, custom domains - Netlify: CLI, netlify.toml, deploy previews, serverless functions, split testing, redirects/headers, forms, Edge Functions - Static Hosting: AWS S3 + CloudFront, Cloudflare Pages, CDN caching, cache invalidation, custom domains, Terraform - Server Deployment: VPS setup (Ubuntu), Nginx, PM2, Let's Encrypt, firewall, SSH hardening, zero-downtime - Environment Management: Dev/staging/production, env vars per environment, feature flags, secrets management - Feature Flags & Progressive Delivery: LaunchDarkly, Flagsmith, percentage rollouts, A/B testing - Zero-Downtime Deployments: Blue-green, canary, rolling updates, health checks, graceful shutdown --- ## Operations & Security - Monitoring & Observability: Logging (structured JSON), metrics (CPU, memory, request/error rate, latency), tracing (OpenTelemetry), uptime monitoring, alerting - Error Tracking: Sentry setup (Next.js/React), source maps, error grouping, breadcrumbs, user context, release tracking - Performance Monitoring: Core Web Vitals (LCP, CLS, INP), Lighthouse CI, RUM, performance budgets, synthetic testing - SEO & Analytics: Google Search Console, sitemap, robots.txt, structured data (JSON-LD, Schema.org), Google Analytics 4, Plausible, A/B testing - Logging & Structured Logs: Structured JSON logging, log levels, aggregation, ELK/Loki, correlation IDs - Alerting & Incident Response: Alert rules, PagerDuty, runbooks, postmortems, escalation policies - Disaster Recovery & Backups: Backup strategies, RTO/RPO, failover, disaster recovery plans - Security Hardening: OWASP Top 10, CSP headers, rate limiting, DDoS protection (Cloudflare), dependency auditing (npm audit, Snyk), helmet.js, CORS, input sanitization, HTTPS - CORS & CSRF: Cross-origin requests, CORS headers, CSRF tokens, same-origin policy - Authentication & Authorization: JWT, OAuth 2.0, sessions, RBAC, API keys, passkeys - Secrets Management: Environment variables, HashiCorp Vault, key rotation, secret scanning - OWASP Top 10: Injection, broken auth, XSS, CSRF, SSRF, security misconfiguration, and more - SSL/TLS & HTTPS: Certificates, Let's Encrypt, HSTS, HTTPS setup, certificate pinning --- ## Learning Roadmaps ### HTML Roadmap (36 topics, ~40 hours) 1. Foundations (~6h): Getting Started, Structure, Head/Meta, Elements, Paragraphs/Headings, Text Formatting, Lists 2. Content & Navigation (~6h): Links, Images, Tables, Forms, Input Types, Validation, Buttons 3. Media & Graphics (~7h): Audio/Video, Iframes, Canvas, SVG 4. Semantic & Modern (~7h): Semantic HTML, Data Attributes, Custom Elements, Shadow DOM, Template/Slot, Web Components 5. Web APIs & i18n (~7h): Microdata, Open Graph, i18n, Storage, History API, Geolocation, Drag & Drop, Web Workers 6. Production & Advanced (~7h): Accessibility, Performance, Security, Spec/DOCTYPE ### CSS Roadmap (40 topics, ~40 hours) 1. CSS Fundamentals (~6h): Getting Started, Selectors, Cascade, Inheritance, Box Model, Display 2. Spacing & Visuals (~6h): Sizing, Margins/Padding, Borders, Colors, Backgrounds, Gradients, Shadows 3. Typography & Variables (~5h): Typography, Text Styling, @font-face, CSS Variables 4. Layout Systems (~6h): Flexbox, Grid, Positioning, Z-Index 5. Motion & Effects (~5h): Transforms, Transitions, Animations, Filters, Clip/Mask 6. Responsive & Architecture (~7h): Media Queries, Container Queries, Responsive, Functions, Scroll Snap, Architecture, CSS Modules, Print, Critical CSS 7. CSS-in-JS & Modern (~7h): CSS Modules, Styled Components, Tailwind, Container Queries, Nesting/Layers ### JS Roadmap (41 topics, ~45 hours) 1. Fundamentals (~6h): Getting Started, Variables, Data Types, Operators, Control Flow, Loops 2. Functions (~5h): Functions, Arrow Functions, Closures, HOF 3. Objects & OOP (~4h): Objects, this, Classes, Prototypes 4. Browser APIs (~5h): DOM, Events, Event Loop, Error Handling 5. Async JavaScript (~5h): Promises, Async/Await, Fetch, WebSockets 6. Advanced Language (~5h): Modules, Generators, Iterators, Collections, Proxies, Symbols, TypedArrays 7. Web & Production (~8h): Web Workers, Service Workers, Design Patterns, Functional Programming, TypeScript, Testing, Security 8. Performance & Production (~7h): Performance, Bundle Optimization, Memory, Monitoring, PWA ### AI Roadmap (43 topics, ~50 hours) 1. AI Foundations (~7h): Getting Started, LLM Fundamentals, Tokenization, Architecture 2. Prompt Engineering (~7h): Prompts, Prompt Patterns, Chain-of-Thought, Few-Shot, Structured Outputs 3. Retrieval & RAG (~7h): RAG, Chunking, Vector DBs, Embeddings, Hybrid Search 4. Agents & Tool Use (~7h): MCP, Function Calling, Tool Use, Agent Orchestration, Multi-Agent 5. APIs & Deployment (~7h): OpenAI, Anthropic, Open Source, Model Deployment, Cost 6. Training & Production (~9h): Fine-tuning, SFT/DPO/RLHF, Datasets, Evaluation, Distillation, Guardrails, Monitoring, Caching, Rate Limiting 7. Multimodal & Frontier (~8h): Vision, Audio, Function Calling, Reasoning, Governance ### Python Roadmap 1. Fundamentals: Variables, Types, Strings, Numbers, Booleans, Control Flow 2. Data Structures: Lists, Tuples, Dicts, Sets, Comprehensions 3. Functions: Functions, Lambdas, Modules, Standard Library 4. OOP: Classes, Magic Methods, Inheritance, Data Classes, Properties 5. Advanced: Decorators, Metaclasses, Type Hints, Concurrency, Asyncio 6. Testing & Tooling: Pytest, Packaging, Linting, Virtual Environments 7. Ecosystem: Regex, Logging, Best Practices ### Web Development Roadmap (35 topics, ~50 hours) 1. Version Control (~7h): Git Basics, Branching, Remote, PRs, GitHub Actions 2. Package Management (~7h): npm, Yarn/pnpm, ES Modules, Task Runners, Env Vars 3. Build Tools (~8h): Vite, Webpack, esbuild, Compilers, Code Splitting, CSS Preprocessors 4. Testing (~8h): Unit, React Testing, Integration, E2E, Linting 5. CI/CD (~7h): GitHub Actions, CI, CD, Docker 6. Deployment (~7h): Vercel, Netlify, Static, Server, Environments 7. Production Operations (~6h): Monitoring, Error Tracking, Performance, SEO, Security Hardening --- ## About ForgeLearn ForgeLearn provides practical, hands-on engineering documentation with a focus on real-world development. Content covers the full stack from frontend fundamentals to production DevOps and AI engineering. All documentation includes practical code examples, configuration samples, and best practices. Built with Next.js 16, React 19, TypeScript. Dark terminal aesthetic with green (#00FF41) accent. © ForgeLearn. All rights reserved.