Onboarding has never
been this simple.
Your data, your control. Drop your knowledge base, link it, or write it. Ferrata turns it into a verified onboarding path in minutes, and tells you what each person actually knows.
Free and open source · runs on your own machine · your data never leaves.
Material
drop files, link your wiki, point it at a checkout on disk, or just write it
Questions
it asks what it needs to know
Plan
review and trim before it builds
Build
verified modules, sources cited
Ready
test what each person knows
Everything you need to onboard a team.
Drop, link, or write
Files, a link to your wiki or knowledge base, a checkout of your code already on the machine, or just type it. It grounds on your material and cites every source.
Review before it builds
See the plan, trim what you don’t need. You only build the modules you keep.
Your secrets stay in
Contextia? strips keys and tokens before any model sees them; internal IPs and hostnames are protected, then restored into the course.
Honest readiness
Not a completion bar. What each person actually knows: solid, shaky, or untested. And the dangerous “sure and wrong”.
A team in minutes
Generate once, onboard many. Assign it, set a deadline for each person, watch readiness.
Your data, your control
Runs where your knowledge lives: local or your own server. Nothing has to leave.
Onboarding is broken. Measurably.
Ferrata does not order laptops, issue badges or chase signatures: plenty of tools do that well, and they do it in an afternoon. It takes on the part that costs months, getting what lives in your docs and in your team's heads into a new person's head, and proving it landed.
More content is not the fix. Course generators write pages but never check what stuck. Learning platforms count completions, which say nothing. Before building Ferrata we studied fifteen commercial platforms and the entire open-source landscape: not one combines the six things below.
Cites its sources
Every module links back to the material it came from. No made-up training.
You approve the plan
Review and trim the concept map before a single module is written.
Tests where they belong
Scenario questions after every concept, not a quiz dumped at the end.
Knowledge that stays
Spaced repetition brings each concept back right before it fades.
Readiness, not completion
Solid, shaky, untested, and the dangerous “sure and wrong”, per person.
Yours, entirely
Self-hosted, your own AI key, inference at cost. Nothing to subscribe to.
An honest claim: verified knowledge is a leading indicator of performance, not a guarantee of it. Tools that promise more are measuring less.
It runs where your knowledge lives.
Local, or on your own server. Nothing has to leave. Sensitive material passes through Contextia?: secrets are stripped before any model sees them; internal addresses and server names are protected, then put back into the finished course. You don’t depend on any single AI vendor. Ferrata just orchestrates.
Every number here is reproducible.
The end to end suite drives the whole thing, background worker included, against a deterministic mock model: it verifies the real flow in a couple of minutes without spending a cent on a provider. Clone the repository and run the four commands yourself.
What that price is, and is not. It is one course, from one repository, on one budget: 14 modules and 52 test questions. It is not a price list. Grounded generation carries the retrieved excerpts into every module call, so a course written from a short brief costs materially less than one built on a codebase. Generation is billed to your own key, and every course shows a receipt of what it actually spent beside the estimate it gave you beforehand, so the number can be checked against your provider invoice rather than believed.
Try a model before you spend on it
One button puts a small module through all eight stages of the pipeline with the models you picked, and reports what each one cost. About twenty cents on a strong hosted model, nothing on a local one: a model that does not suit Ferrata costs the price of one module to find out about, instead of half a course.
The ledger is the receipt
Every call is recorded with its tokens, its cost, and the reason it was discarded if it was. The estimate shown before you build comes from the same numbers, so it can be wrong in public rather than quietly.
An honest limit: the hosted-model figure is a single course. The local rows are one run each and stay provisional until there are five. Everything above traces to a file in the repository; nothing here is an estimate dressed as a measurement.
Free to run. Pay only when your team needs the controls.
Ferrata is free and self-hosted. You bring your own AI key, so generation runs at cost with no markup and your data never leaves. Organisation controls are on the way, and one promise holds either way: what ships free stays free.
Free
€0 · you host it
For individuals and teams who host it themselves. The whole product, not a trial.
- Author, generate and study verified courses
- Roster, assignments and a deadline for each person
- Readiness dashboard: solid, shaky, untested, “sure and wrong”
- Spaced repetition built in
- Bring your own AI key, any major provider, or a local model
- Contextia?: secrets stripped before any model sees them
Teams
Coming soon
For organisations that need controls around the product, not a bigger product.
- Everything in Free, plus:
- SSO/SAML and SCIM provisioning
- Central key management with per-team budgets
- Separate workspaces per team, with roles
- Audit log and exportable readiness reports
- Priority support
Enterprise
Custom
For compliance, scale and full data isolation.
- Everything in Teams, plus:
- Centrally enforced protection policies, retention and audit
- Air-gapped installation support
- SLA and signed DPA
Generate once for the price of a coffee. Save days on every hire.
With your own key, a full course costs about ~€2 once on a top model, and one course onboards your whole team, forever. Put in your numbers:
You save, roughly
€15,000
per onboarding round · generation cost: ~€2
These are your assumptions, not our claims. Move the sliders: even one day saved per hire dwarfs the cost of generating the course.
Install it in minutes.
Node and SQLite, no external service required. It runs on a laptop or a modest company VM, no GPU. Clone it and start it, or pull the image: either way you are a few lines from running.
# needs Node 22+ and git
npm install -g pnpm@10
git clone https://github.com/getferrata/ferrata.git
cd ferrata
pnpm install
pnpm build
pnpm start# PowerShell. Already have Node 22+ and git? Start at npm install.
# Smoother inside WSL2 (wsl --install -d Ubuntu): SQLite is a native module.
winget install --id OpenJS.NodeJS.LTS -e --accept-source-agreements --accept-package-agreements
winget install --id Git.Git -e --accept-source-agreements --accept-package-agreements
# Close this window and open a new PowerShell, so it picks up the new PATH.
npm install -g pnpm@10
git clone https://github.com/getferrata/ferrata.git
cd ferrata
pnpm install
pnpm build
pnpm start# one command, nothing to clone or build
docker run -d --name ferrata -p 3000:3000 \
-v ferrata-data:/data ghcr.io/getferrata/ferrata:latest
# building from source instead? clone the repo, then:
docker compose up -d --buildThen open http://localhost:3000. The first account you register becomes the author and sign-ups close behind it: after that, people come in through invite links you create, and the link decides whether they arrive as a learner or as someone who can build. In Settings, paste an AI key from any major provider, or point it at a local model server, and you are ready to rig your first path.
Putting it on a server? The deployment guide covers systemd, TLS, log rotation, backups and installs on machines with no internet access.
Hosted and managed is coming too, for teams who would rather not host it themselves. Same engine, your data still isolated.