Recruiting intelligence that gets sharper over time.
RolaDeck connects to your ATS and scores every inbound application against structured role playbooks. As candidates move through your pipeline it learns which signals actually predict success at your company, and recalibrates accordingly.
It's built as a multi-tenant cloud product. Sign up with your work email and you get an isolated workspace. Anyone else at your company who signs up with the same domain joins the same workspace automatically.
Create an account with your work email. From there you can add your company name, website, blog posts, case studies, articles — anything that gives context about what your company does and what good looks like. That context is used to calibrate AI sourcing and outreach so it's specific to you rather than generic.
Link your Greenhouse account and RolaDeck starts pulling in applications automatically. Every candidate is classified and scored as they arrive. You can also score candidates manually if you want to assess someone outside of the ATS flow.
When a candidate comes in, RolaDeck reads their profile and works out what they actually are — not what role they happened to apply for. Someone with a machine learning background who applied for a backend role gets classified as an ML engineer. A product marketer who started out in content gets matched against both playbooks and scored on each.
This matters because most candidates don't apply for the exact role they're best suited for. Classification based on career history gives you a more accurate pool, and surfaces talent for future roles you haven't opened yet.
Each role playbook has three tiers: T1 (must-haves), T2 (differentiators), T3 (rare upside). Candidates are scored across all three at whatever seniority level you're hiring for. No scoring rubrics to maintain, no spreadsheets. The Score page also has a detect button — paste a profile, click detect, and it suggests the most relevant playbooks with confidence scores before you commit to scoring.
As candidates move through your pipeline RolaDeck tracks which criteria actually correlated with people getting hired. Scores recalibrate over time so the tool reflects your hiring bar, not a generic one.
AI searches GitHub, conference talks, blogs, and the open web for candidates who match your playbook criteria. You get real profiles with rationale, boolean search strings for LinkedIn and GitHub, a target company list, and a draft outreach message. All of it shaped by the company context you added during setup.
Every scored candidate is saved and organised by playbook. Candidates can appear under multiple playbooks if they matched more than one. Filter by category, search by name, and filter by pipeline stage within each role. When a new role opens you already have a ranked shortlist to start from.
57 built-in playbooks across Tech, Marketing, and Sales. Each one has scoring criteria, seniority signals, sourcing strings, interview stages, and red flags.
You can also create your own playbooks per company — three ways:
- Upload a markdown file — use the downloadable template, fill it in, upload it. The parser picks up criteria tiers, red flags, seniority signals, comp ranges, and sourcing strings from the markdown structure.
- Import from a URL — paste a raw GitHub URL (or any direct link to a
.mdfile). GitHubblob/links are normalised toraw.githubusercontent.comautomatically. - Build manually — a form to fill in name, category, description, criteria rows, and red flags directly in the browser.
Custom playbooks are per-tenant, stored alongside your candidate pool, and show up in scoring, sourcing, and the talent pool the same way built-in playbooks do.
Connect your AI provider and ATS from Settings. Supports Anthropic Claude, OpenAI, and Perplexity for AI features, and Greenhouse for ATS sync.
- Backend: OCaml + Dream
- Frontend: ReasonML + Melange compiled to React
- Build: Dune
- Auth: PBKDF2-SHA256, HttpOnly session cookies, domain-based multi-tenant isolation
- AI: pluggable provider (Anthropic, OpenAI, Perplexity)
- ATS: Greenhouse sync
OCaml and ReasonML are a deliberate choice. The strong static type system catches entire classes of bugs at compile time — mismatched JSON shapes, missing match cases, incorrect field access — that would surface as runtime errors in a dynamically typed stack. Dream is fast, minimal, and fits the single-binary deployment model well. Melange lets the frontend share type definitions directly with the backend, so the API contract is enforced by the compiler rather than by documentation. It's also the stack Ahrefs runs in production, so it felt like the right fit for a tool built with that context.
This is a working prototype built to validate the concept. A few things worth flagging before treating it as production infrastructure:
Storage. Candidate and session data is stored as flat JSON files under ~/.roladeck/. Writes use atomic rename (write to .tmp, rename into place) which is safe for single-process use. The Greenhouse sync loop runs concurrently with user requests via cooperative multitasking, so concurrent writes to the same tenant's pool are possible under load. A proper deployment would swap the storage layer for Postgres and add a connection pool — the storage interface is isolated enough to make that a contained change.
CORS. The API currently sends Access-Control-Allow-Origin: *. Fine for local dev, should be locked to the frontend origin before any public deployment.
Criterion scoring. Candidate profiles are scored against playbook criteria using keyword matching with stop-word filtering and phrase detection. It's a solid heuristic — significantly better than naive token overlap — but it's still local text matching, not semantic understanding. The AI classification layer (which identifies what a candidate actually is) is the higher-signal part of the pipeline. The keyword scoring is most useful as a structured breakdown and as the input data for the calibration loop, where it gets better over time as real hiring outcomes accumulate.
Session expiry. Sessions are stored indefinitely. A production build would add an expiry timestamp and a cleanup job.
- OCaml 5.x + opam
- Node.js 18+
- Dune 3.14+
# Install OCaml dependencies
opam install . --deps-only
# Install Node dependencies (Melange compiler + Vite)
npm installdune build
dune exec bin/main.exe # backend on :4000
npm run dev # frontend on :3000Connect your AI provider and Greenhouse from Settings. Data is stored per-tenant under ~/.roladeck/tenants/{company_id}/.