COREAdvanced coverage
JavaScript
The language executing behavior in a browser and in JavaScript runtimes.
- Why it exists
- Documents need behavior: input, state transitions, network requests, and rendering loops.
- Where it fits
- Browser components, game logic, scripts, and server runtimes.
- What to understand first
- Values and functions · Scope and state
- Distinguish it from
- TypeScript adds compile-time reasoning; it still emits JavaScript. Python and C# use different runtimes.
Repository evidence & current limits
- LearnLab · Client learning components
- NNPlays · Portal and game implementations
- Vyora · Application and automation source
More independent algorithm and concurrency projects; browser-specific scheduling subtleties.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREAdvanced coverage
TypeScript
A static type checker and JavaScript tooling language.
- Why it exists
- Describe relationships between values and catch incompatible states before running code.
- Where it fits
- Domain models, component props, API contracts, reusable packages.
- What to understand first
- JavaScript · Runtime versus compile time
- Distinguish it from
- A type assertion changes checker knowledge, not incoming data. Runtime validation remains necessary.
Repository evidence & current limits
- LearnLab · Typed curriculum and React source
- Vyora · Application and shared package source
- NNPlays · Typed games and graphics applications
Larger multi-file compiler projects and advanced library declaration exercises.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
HTML & the DOM
HTML expresses document semantics; the DOM is the browser's parsed object tree.
- Why it exists
- A browser and assistive technologies need structure, relationships, and controls.
- Where it fits
- The document boundary below application frameworks.
- What to understand first
- Elements and attributes
- Distinguish it from
- A visual appearance is not semantic meaning. React eventually asks the browser to update a DOM.
Repository evidence & current limits
- LearnLab · Static exported pages
- NNPlays · Portal and game shells
Deeper browser rendering, navigation/history, metadata, iframe and progressive-enhancement sequences.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
CSS
A rule system for layout, presentation, responsive behavior, and motion.
- Why it exists
- Content needs to adapt to space, input, readability, and user preferences.
- Where it fits
- Dashboards, websites, game HUDs, and accessible controls.
- What to understand first
- HTML · Box model
- Distinguish it from
- Flexbox arranges a dimension; Grid coordinates tracks in two dimensions. Neither replaces semantic structure.
Repository evidence & current limits
- LearnLab · Responsive lesson and academy styles
- Vyora · Application UI styles and Tailwind configuration
- NNPlays · Portal and game HUD layouts
More visual bug hunts for typography, container queries, reduced motion, and production style architecture.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
React
A component model that describes UI from state.
- Why it exists
- Keep interactive interfaces consistent as data and user actions change.
- Where it fits
- Presentation boundaries, state ownership, effects that synchronize external systems.
- What to understand first
- JavaScript closures · HTML · State and identity
- Distinguish it from
- React describes UI; Next.js adds routing, rendering architecture, and deployment conventions.
Repository evidence & current limits
- LearnLab · Learning players and local progress context
- Vyora · Application interfaces
- NNPlays · Selected game interfaces and R3F scene components
Larger component builds, executable React test projects, Suspense and advanced profiling.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
Next.js App Router
A React framework with routes, layouts, rendering choices, and server capabilities.
- Why it exists
- Applications need a coherent boundary between URLs, data, rendered output, and deployment.
- Where it fits
- LearnLab exports static assets. Server-capable products need a runtime for request-time work.
- What to understand first
- React · HTTP · Server versus browser
- Distinguish it from
- Static generation is build-time work; server rendering is request-time work; client rendering runs in the browser.
Repository evidence & current limits
- LearnLab · next.config.ts static export and App Router
- Vyora · App Router applications and OpenNext deployment
Dedicated advanced Next.js caching, streaming, route-handler and deployment exercises.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
Node.js & npm
Node runs JavaScript outside a browser; npm resolves packages and runs project scripts.
- Why it exists
- Build tools, automation, server code, and repeatable dependency installation need a runtime.
- Where it fits
- Development, CI, package workspaces, and server processes.
- What to understand first
- JavaScript modules · Files and processes
- Distinguish it from
- Browser code has DOM APIs; Node has process and filesystem APIs. Build-time access is not browser access.
Repository evidence & current limits
- LearnLab · package.json and Node verification scripts
- Vyora · npm workspaces and automation
- NNPlays · Build, asset, and test scripts
Hands-on filesystem, CLI packaging, process management, and dependency incident scenarios.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
HTTP, REST & JSON
HTTP exchanges requests and responses. JSON serializes a restricted data shape. REST is an architectural approach to resources.
- Why it exists
- Independent clients and services need contracts across unreliable networks.
- Where it fits
- Browser-to-service boundaries, retries, validation, pagination, and errors.
- What to understand first
- URLs · Objects and serialization
- Distinguish it from
- A successful network exchange does not imply an authorized or successful business operation.
Repository evidence & current limits
- LearnLab · API curriculum
- Vyora · Server and database integration boundaries
- NNPlays · Progression and score integrations
Executable webhook signing, pagination, versioning, and eventual-consistency scenarios.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREAdvanced coverage
SQL & relational design
A language and model for querying related sets while preserving data constraints.
- Why it exists
- Relationships and invariants should survive every caller, not just one UI.
- Where it fits
- Persistent application state, reports, integrity, and transactions.
- What to understand first
- Sets · Keys and relationships
- Distinguish it from
- The SQL lab executes SQLite. PostgreSQL has different dialect, planning, concurrency, and policy features.
Repository evidence & current limits
- LearnLab · SQL curriculum and browser database
- Vyora · Migrations and database tests
- NNPlays · Progression database migrations
Actual multi-session PostgreSQL isolation, lock investigation, and production EXPLAIN practice.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
PostgreSQL
A relational database engine with transactions, constraints, indexes, row policies, and procedural functions.
- Why it exists
- Concurrent clients need a durable source of authority and coherent integrity rules.
- Where it fits
- The database foundation beneath Supabase integrations.
- What to understand first
- SQL · Transactions
- Distinguish it from
- A database engine is not an SDK. PostgreSQL behavior cannot be inferred from SQLite execution alone.
Repository evidence & current limits
- Vyora · SQL/PLpgSQL migrations, policies and transactional tests
- NNPlays · Database functions and migrations
No live PostgreSQL execution; transaction/isolation teaching includes conceptual traces and checked answers.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
Supabase
A platform combining PostgreSQL with authentication, generated APIs, and additional services.
- Why it exists
- Applications need authenticated access to database capabilities without rebuilding every platform layer.
- Where it fits
- Database + auth + policies + API; Realtime and Storage only where the workload needs them.
- What to understand first
- PostgreSQL · HTTP · Authentication and authorization
- Distinguish it from
- The public client is not trusted server authority. A service-role credential changes the security boundary.
Repository evidence & current limits
- Vyora · Client/SSR integrations, auth and database migrations
- NNPlays · Auth, RPC, Realtime and Storage source paths
Real authenticated integration tests, storage policy scenarios, Realtime and Edge Function modules.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
Row-level security
Database policy evaluation that restricts which rows a principal can access or write.
- Why it exists
- Tenant isolation must hold even when a caller bypasses the UI.
- Where it fits
- The database authorization boundary, alongside table privileges and constraints.
- What to understand first
- SQL · Identity · Trusted membership data
- Distinguish it from
- Hiding a button is presentation. RLS evaluates a database operation regardless of how the request was constructed.
Repository evidence & current limits
- Vyora · Tenant policy migrations and authorization tests
- NNPlays · Authenticated progression policies
The simulator models selected rules; real policy integration tests remain mandatory for a deployed schema.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
Application security
Designing and verifying trust boundaries, permissions, input handling, and secret ownership.
- Why it exists
- A system must reject unauthorized actions even when a caller behaves unexpectedly.
- Where it fits
- Browser, API, database, build, and operational boundaries.
- What to understand first
- HTTP · Data flow · Authentication
- Distinguish it from
- Authentication establishes identity; authorization decides permitted actions on specific resources.
Repository evidence & current limits
- LearnLab · Sandbox, CSP and local backup validation
- Vyora · Authentication, authorization and audit boundaries
- NNPlays · Policies, identity and score validation
A dedicated deeper academy for OAuth, CSRF, password handling, supply-chain review, and attack/defend builds.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
Git & GitHub
Git records a graph of snapshots; GitHub supports collaboration, review, and automation around repositories.
- Why it exists
- Changes must be understandable, recoverable, and reviewable by other engineers.
- Where it fits
- Daily development, releases, pull requests, and CI.
- What to understand first
- Files · Snapshots and graph ancestry
- Distinguish it from
- A branch is a movable reference, not a separate copy of the whole history. Fetching does not merge.
Repository evidence & current limits
- LearnLab · Repository and Actions workflow
- Vyora · Workspace CI and verification workflows
- NNPlays · Game/build workflows and test gates
More hands-on remote collaboration and repository recovery exercises outside the bounded simulator.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
Testing & debugging
Tests encode observable contracts; debugging reduces uncertainty about a failure.
- Why it exists
- A change needs evidence beyond plausible code or a confident explanation.
- Where it fits
- Pure logic, integrations, user flows, regression gates, and failure diagnosis.
- What to understand first
- Functions and contracts · Reproduction
- Distinguish it from
- A mock proves behavior against the mock. Integration evidence requires the actual boundary being claimed.
Repository evidence & current limits
- LearnLab · Node logic tests and static verification
- Vyora · Domain, integration and Playwright suites
- NNPlays · Deterministic simulation, save and browser tests
Full test authoring workspaces, contract testing, richer flaky-test and mutation-testing exercises.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
Monorepos & architecture
The placement of responsibilities and dependencies across applications and reusable modules.
- Why it exists
- Business rules need a clear authority instead of drifting copies in every interface.
- Where it fits
- Domain, presentation, infrastructure, package, and transactional boundaries.
- What to understand first
- Modules · Contracts · State ownership
- Distinguish it from
- A monorepo is repository organization. It does not automatically imply microservices or sound boundaries.
Repository evidence & current limits
- Vyora · Two applications and shared workspace packages
- NNPlays · Portal and independently built game applications
Deeper dependency graph refactoring, architectural decisions, event-driven workflows and distributed consistency.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
Cloudflare & deployment
Hosting and edge delivery services with different contracts for static assets and server workloads.
- Why it exists
- A built artifact must reach browsers reliably with sensible caching, headers, and rollback.
- Where it fits
- LearnLab static Pages; server-capable Workers deployment in the reference ERP.
- What to understand first
- HTTP · Build artifacts · DNS and HTTPS concepts
- Distinguish it from
- An exported site cannot execute request-time route handlers. A Worker is a compute runtime, not merely a static folder.
Repository evidence & current limits
- LearnLab · Static export, headers and deployment verification
- Vyora · OpenNext/Workers configuration
- NNPlays · Static publishing and asset build configuration
Dedicated DNS/TLS incident, cache headers and preview-to-production operational exercises.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
IMPORTANTFoundation coverage
PWA & offline behavior
Install metadata and service-worker-controlled caching can give a website app-like capabilities.
- Why it exists
- A learner or player may have unreliable connectivity and needs predictable update behavior.
- Where it fits
- Browser storage, cache strategies, versioning, and installability.
- What to understand first
- Browser lifecycle · HTTP caching
- Distinguish it from
- A web manifest alone does not prove offline functionality. Cached application code can also become stale.
Repository evidence & current limits
- LearnLab · Manifest and service worker
- NNPlays · Portal service worker and install assets
Comprehensive offline upgrade, conflict, eviction, and recovery simulations.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
Canvas 2D & game loops
Canvas draws pixels; a game loop schedules input, simulation updates, and frames.
- Why it exists
- Games need explicit control over time, coordinates, movement, and rendering.
- Where it fits
- 2D games, visualizations, collision experiments, and responsive rendering surfaces.
- What to understand first
- JavaScript · Vectors · requestAnimationFrame
- Distinguish it from
- A frame count is not elapsed time. The display refresh rate is not a guaranteed physics update rate.
Repository evidence & current limits
- NNPlays · Plain Canvas game implementations
- LearnLab · Interactive game loop experiment
A complete integrated game editor and richer physics, pathfinding, and gamepad input projects.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
IMPORTANTIntermediate coverage
Three.js & WebGL
WebGL exposes GPU rendering; Three.js provides a scene graph and rendering abstractions above it.
- Why it exists
- A browser needs cameras, geometry, materials, lights, and efficient render submission for 3D.
- Where it fits
- 3D game scenes, interactive assets, graphics applications.
- What to understand first
- JavaScript · Vectors and transforms · Game loops
- Distinguish it from
- NNPlays includes both Three.js and a custom WebGL2 renderer. One does not imply the other.
Repository evidence & current limits
- NNPlays · Vendored Three.js, R3F application, and independent WebGL2/GLSL renderer
- LearnLab · Opt-in 3D playground
No GLB upload/animation/physics in this playground; shader programming, instancing and LOD need deeper modules.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
SPECIALISTNot Covered coverage
React Three Fiber, Drei & postprocessing
A React renderer for Three.js plus helpers and effect tools used by selected 3D applications.
- Why it exists
- Compose scene behavior with a component model while retaining rendering and performance responsibilities.
- Where it fits
- A subset of the reference 3D stack.
- What to understand first
- React · Three.js
- Distinguish it from
- A component abstraction does not remove GPU costs, resource disposal, or frame budgets.
Repository evidence & current limits
- NNPlays · Chess game package dependencies and scene implementation
Framework-specific lessons and labs remain future coverage. The linked scene lesson teaches prerequisite concepts, not R3F, Drei, Zustand or postprocessing APIs.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
SPECIALISTNot Covered coverage
Phaser
A browser game framework with scenes and supporting input, animation, and asset facilities.
- Why it exists
- Some games benefit from established 2D engine infrastructure.
- Where it fits
- Selected reference games alongside independent custom engines.
- What to understand first
- JavaScript · Game state · Coordinates
- Distinguish it from
- Engine APIs organize game work; they do not replace knowledge of timing, collision, and state.
Repository evidence & current limits
- NNPlays · Game manifests and Phaser implementations
A Phaser-specific implementation sequence is still planned. The linked lesson teaches prerequisite game-state principles, not Phaser APIs.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
IMPORTANTFoundation coverage
Blender, Python & GLB
A 3D authoring tool and scriptable asset pipeline that can produce browser-loadable glTF/GLB assets.
- Why it exists
- Assets need repeatable transforms, materials, export settings, and validation before a game loads them.
- Where it fits
- Mesh creation → export → optimization → loader → scene → measured frame.
- What to understand first
- 3D transforms · Materials and UVs · Python scripting
- Distinguish it from
- A .blend source file is an authoring artifact; a GLB is an exchange asset. Export success does not prove visual or performance correctness.
Repository evidence & current limits
- NNPlays · bpy/bmesh/mathutils scripts, GLB generation and asset validation
External Blender practice, batch asset generation, armatures, UV authoring, and real reimport validation.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
IMPORTANTIntermediate coverage
Python
A general-purpose language well suited to scripts, data transformation, and automation.
- Why it exists
- Repeated file and asset operations should be explicit, reproducible programs.
- Where it fits
- LearnLab automation workshop and NNPlays asset tooling; no Python web backend was inferred.
- What to understand first
- Programming foundations · Files and structured data
- Distinguish it from
- Python's dynamic runtime and coroutine behavior differ from TypeScript checking and C# Tasks.
Repository evidence & current limits
- LearnLab · Starter and applied workshop
- NNPlays · Asset scripts including Blender, Pillow and NumPy
More virtual-environment, CLI packaging, testing, and asset automation projects; no browser Python runtime added.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
IMPORTANTIntermediate coverage
C# & .NET
A statically typed language and runtime ecosystem for applications, services, and tools.
- Why it exists
- Transfer engineering ideas into explicit value/reference models, generic collections, LINQ, and Tasks.
- Where it fits
- An owner-requested language academy, independent of the current JavaScript-heavy repository footprint.
- What to understand first
- Programming foundations · Types and contracts
- Distinguish it from
- TypeScript types are erased into JavaScript. C# types participate in the .NET compilation/runtime model.
Repository evidence & current limits
- Owner requirement · Dedicated C# academy; no current reference-repository C# source claimed
No CLR execution in the browser; compiled projects, ASP.NET integration and deeper advanced practice remain external.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
IMPORTANTIntermediate coverage
Performance engineering
Measuring a workload against explicit time, memory, network, and rendering budgets.
- Why it exists
- Optimization should improve an observed bottleneck on a relevant device.
- Where it fits
- Web responsiveness, bundles, game frame times, assets and GPU resources.
- What to understand first
- Runtime boundaries · Measurement · Rendering
- Distinguish it from
- A budget estimate is a planning tool. Only measurement can establish the performance of a real application.
Repository evidence & current limits
- Vyora · Lazy loading and performance-oriented application boundaries
- NNPlays · Frame/asset budgets and rendering optimizations
- LearnLab · Deferred learning engines
Profiler recordings, real Core Web Vitals analysis, GPU capture and memory-leak investigations.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
COREIntermediate coverage
Accessibility & responsive engineering
Designing interaction and content to work across input methods, capabilities, and display sizes.
- Why it exists
- Every learner should be able to operate the interface and perceive feedback.
- Where it fits
- Semantics, focus, forms, contrast, motion, tables, and game HUDs.
- What to understand first
- HTML · CSS · User interactions
- Distinguish it from
- ARIA does not repair every interaction. Native controls and meaningful structure are the starting point.
Repository evidence & current limits
- LearnLab · Keyboard controls, focus, responsive learning interfaces
- NNPlays · Touch and responsive HUD behavior
- Vyora · Responsive application interface patterns
A dedicated accessibility sequence with screen-reader recordings, before/after defects and broader assistive-technology review.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.
IMPORTANTIntermediate coverage
AI-assisted engineering
Using models to propose explanations, implementation changes, tests, and reviews while retaining human verification.
- Why it exists
- AI can accelerate exploration, but fluent output may still invent APIs, tests, or successful results.
- Where it fits
- Repository navigation, bounded change briefs, debugging, review, and deterministic checks.
- What to understand first
- Code reading · Testing · Debugging · Version control
- Distinguish it from
- An assistant's assertion is not an observed result. Record what was run, what it proved, and what remains untested.
Repository evidence & current limits
- LearnLab · Prompting academy, Prompt Repair, AI Engine Lab and verification lessons
The preserved AI-fluency course covers advanced prompting and model concepts. Engineering practice still needs longer repo-aware agent scenarios, multi-file coding tasks and executed capstone evidence; no paid model integration is required.
Evidence describes inspected source, not a claim that every feature is deployed. Private production details are intentionally translated into synthetic teaching examples.