ONE PATH. REAL PROJECTS.
Learn KetJS, step by step
Build a website and a task application while learning ketjs-view, modules, databases, APIs, security, jobs and deployment. Follow one practical path from your first signal to a reviewed application.
0.2.0 Preview — APIs may changeHow this learning path works
How this course works#
Follow the numbered lessons in order. Each introduces a small set of ideas, gives you something to build or inspect, and ends with a checkpoint and an exercise. The course targets KetJS 0.2.0 preview; APIs may change before 1.0.
Frontend experiments run in the browser playground. Backend work runs in your own terminal with Node 24+, a real KetJS deployment and SQLite. The completed View project and backend project with learning CLI are downloadable reference labs.
The first stages build working examples. Later stages guide explicit extensions such as sessions, themes, providers and PostgreSQL; they identify their prerequisites rather than pretending every integration is included in the starter. Automated lab checkpoints cover API behavior, company isolation and durable jobs. Other checkpoints are reviewed manually.
Mark a lesson complete after you can explain and demonstrate its checkpoint. Progress stays in this browser; it is not a certification or a server-side assessment.
Start here
Build the frontend
- 02
Create your first View project
Scaffold a standalone ketjs-view project, inspect its files, and run a production build.
- 03
Write a pure TSX page
Compose markup with functions, typed props, lists and accessible HTML while keeping rendering pure.
- 04
Build a counter with signals
Create state once per island, update it through events, and understand why the view returns a function.
- 05
Grow the counter into a todo list
Handle form submission, derive counts, and preserve item identity with keyed lists.
- 06
Validate a form with a shared schema
Cast and validate form values, present useful errors, and retain the server validation boundary.
- 07
Own browser effects and cleanup
Attach browser resources after hydration and release them when the island is removed.
- 08
Understand effects and reactive dependencies
Learn when an effect runs, what it tracks, how cleanup works, and why async work needs an explicit owner.
- 09
Fetch data without render side effects
Build a searchable list with loading, empty, error and retry states, request cancellation and safe hydration.
- 10
Publish a small static website
Build a multi-page website with metadata, native links, assets and explicit islands.
- 11
Generate pages from content
Turn a small content collection into static routes and learn when client navigation is worth adding.
Compose the backend
- 12
Start the local backend lab
Scaffold a real Node application, run the learning CLI, and inspect the completed Todo API reference.
- 13
Compose a module and inspect its manifest
Declare one capability with a model and functions, then inspect the checked composition.
- 14
Understand workspaces and deployment roles
Select a complete application composition and distinguish HTTP, worker and datastore responsibilities.
Work with data
- 15
Model tasks and company scope
Declare a typed Todo model, inspect the generated schema, and distinguish identity from scope.
- 16
Read and order data with queries
Use checked table handles, explicit projections and predictable ordering to build your task list.
- 17
Validate writes with functions and changesets
Create tasks through a named operation with checked input, declared effects and controlled writable fields.
- 18
Keep related writes atomic
Use one transaction context for business changes and queued work, and design a rollback experiment.
Build the API
- 19
Expose the Todo API through HTTP
Build a bounded JSON facade with method handling, domain calls and useful status codes.
- 20
Document and inspect API contracts
Distinguish function signatures from route metadata and keep generated API documentation aligned with deployment.
- 21
Connect an island to the API
Manage pending, success and error states around a real request while preserving user input.
Protect the application
Present the application
Go beyond requests
- 26
Run durable background work
Enqueue work transactionally, run a real worker, and design handlers that tolerate retries.
- 27
Handle files, outbound services and streams
Design bounded uploads, tenant-owned storage and resumable delivery without buffering everything into memory.
- 28
Expose reports and agent capabilities
Reuse explicit business projections for printable output and machine-readable operations.
Verify and operate
- 29
Test the deployment you actually ship
Exercise real HTTP, scoped data and workers with isolated deployment fixtures and targeted checkpoints.
- 30
Evolve the schema and try PostgreSQL
Plan a schema change, distinguish planning from application, and preserve adapter contracts when changing databases.
- 31
Observe behavior and measure performance
Use structured operational records and reproducible measurements to diagnose the application you built.
- 32
Prepare an evaluation deployment and upgrade
Build an immutable artifact, separate migrations and process roles, and plan an upgrade while KetJS is in preview.