Tutorials
Step-by-step recipes for building on DODIL — from DataK3 buckets to agents.
Enterprise Software
39 tutorialsCRM
13 tutorialsThe Whole CRM in One Bucket
A complete CRM — accounts → contacts → leads → opportunities, plus lead scoring, pipeline forecast, quote/CPQ, campaign attribution, and account-360 — on ONE DataK3 bucket. Seven composable skills, shared master data joined across every workflow, one relationship graph assembled once. 36 tables, no ETL, no second copy. This is the suite; each workflow is its own tutorial.
Build a CRM on DODIL in an Hour: Tables, an Account Graph, a Data-Driven Email Engine, and a Gated Lead Pipeline
The GTM CRM we use to sell DODIL is just DataK3 — one bucket, three pillars. Build your own: merge-keyed contacts/deals/activities, an account-hierarchy graph that rolls up pipeline by corporate family, semantic search over activity notes, an email sequence engine where flows are data, and a cost-gated lead pipeline on Ignite Models. One bucket, one bill.
Scaffold the CRM Master-Data Core on DODIL — Contacts, Deals, Activities, an Account Graph, and Dedup Vectors
Replace the Salesforce + ZoomInfo + Outreach + warehouse stack with one system of record: four merge-keyed master tables on one DataK3 bucket, an account graph that rolls up pipeline by corporate family ($36k across Acme's tree, no flat query gives you that), and a VECTOR(2048) dedup table that catches duplicate contacts before they corrupt every downstream number. One bucket, three pillars — SQL, graph, vector — over one copy of the rows, driven by a FastAPI app you download and run.
Lead to Opportunity on DODIL: a Discovery Warehouse, a Cost-Gated Qualify, and a Sequence Engine That's Just Rows
The discover → qualify → nurture → convert front door of a CRM, on one DataK3 bucket. Discover companies into a warehouse, qualify a bounded batch on Ignite Models (kimi-k2.6) so you only pay for the leads you want, expand the target list by vector lookalike, convert strong buyers into leads + opportunities, and nurture them with an email sequence that's data — walked by a scale-to-zero Ignite engine, tracked by a minimal public app.
Qualify Leads on DODIL: a BANT/MEDDIC Scoring Engine on Ignite Models
Stop guessing which leads are real. Score a lead or opportunity on BANT or MEDDIC with a kimi-k2.6 gate — the per-dimension verdict lands in a lead_scores table, the two-gate policy is a row you edit, and a strong lead auto-qualifies while a mid one routes to a human. One DataK3 bucket, one Ignite app.
Pipeline Forecasting on DODIL: Stages as Data, a Weighted Pipeline, Forecast Categories, and a Family Rollup — with a Risk Gate
The forecast a $30k/yr Clari or Salesforce Forecasting seat sells — weighted pipeline, commit/best-case buckets, a family-weighted rollup no flat query gives you, and an AI risk gate that catches stale commits — is three merge-keyed tables + one graph JOIN + one Models call on one DataK3 bucket. Pure SQL rollups; the AI is the override, not the baseline.
Quote-to-Cash CPQ on DODIL: Products, Price Books, and a Policy-Gated Discount Engine
Turn a won-ish opportunity into a priced, policy-gated quote on one DataK3 bucket: a product catalog, multi-currency price books, quote lines that reprice idempotently, a discount policy that lives as data, and a kimi-k2.6 gate that adjudicates the edge cases your threshold can't.
Tie Marketing Spend to Pipeline: Campaign Attribution on DODIL
Which campaigns actually created pipeline? Model campaigns, members, and touchpoints as merge-keyed DataK3 tables, split won-deal revenue across the campaigns that touched each buyer (first/last/linear/multi-touch), and compute campaign ROI — one bucket, SQL + an optional graph path, a scale-to-zero attributor engine, and a Models-assisted influence split. One bucket, one bill.
Account 360 on DODIL: Assemble the Relationship Graph, Roll Up the Corporate Family, and Find the Whitespace
The graph skill of the CRM suite. Turn accounts, subsidiaries, and inter-company relationships into one assembled DataK3 graph, roll up pipeline by corporate family, score account health, and rank the next product to cross-sell — one bucket, three pillars over one copy of the rows.
ITSM
11 tutorialsFinancial-Services ITSM on DODIL
The ITSM suite, reshaped for regulated IT change — CIs that carry a compliance scope, changes that carry a compliance sign-off, an immutable audit trail, and a CAB gate fronted by a compliance hard gate that holds a change to a regulated CI regardless of the model's decision or a low blast radius. It's the ITSM suite plus one additive overlay, on the same bucket.
Change Management on DODIL — Where the Risk IS the Blast Radius
Build ITSM change management on one DataK3 bucket: a change request reads the CMDB impact graph for its blast radius (typed reverse traversal — part_of doesn't leak), a kimi-k2.6 CAB gate adjudicates {decision, risk, reason} keyed on that blast, a deterministic freeze-window floor hard-routes regardless, and the verdict + a change calendar + a policy row land in SQL. No CMDB in Neo4j, no ticket DB in Postgres, no nightly sync — one copy of the rows.
CMDB Blast Radius on DODIL: Assemble the Graph, Type the Traversal, Roll Up the Impacted Services
The graph skill of the ITSM suite. Turn a CMDB of CIs and typed dependencies into one assembled DataK3 graph, then answer the question a CMDB exists for — if this CI fails, what breaks? — as a hop-ranked blast radius and an impacted-service rollup, over one copy of the rows. The catch every CMDB gets wrong: type your edges or you over-count.
Scaffold the ITSM Master-Data Core on DODIL — CIs, Incidents, a CMDB Graph, and Similar-Incident Vectors
The system of record every ITSM workflow reads: eight merge-keyed master tables on one DataK3 bucket — cis, incidents, problems, changes, services, users, groups, and a typed ci_edges topology — the CMDB dependency graph that turns a failing pg-orders-primary into its full cross-service blast radius in one hop-ranked query, and an inline VECTOR(2048) column on incidents that answers 'have we seen this before?' by meaning. One bucket, three pillars, one copy of the rows.
Auto-Triage Incidents on DODIL: Dedup, Classify, and Route on Ignite
Stop hand-sorting the incident queue. On one DataK3 bucket, a new incident is deduped against similar tickets (vector), scored for blast radius against the CMDB (graph), classified by a kimi-k2.6 gate (category + priority), and routed to the team that fixed the last one — the verdict lands in an incident_triage table and the incident advances new → triaged. One Ignite engine over the ITSM masters itsm/core owns.
Major Incidents on DODIL: Declare the Bridge, Scope the Blast, Run It open → mitigating → resolved
The bridge lifecycle of the ITSM suite. When a P1 fires, a major incident isn't a bigger ticket — it's a war room with a commander and a clock. On one DataK3 bucket, declare a major incident from the ticket, scope its TYPED CMDB blast radius (graph), roll it up to the business services it takes down, and open a bridge you track open → mitigating → resolved — the underlying incident closing with it. Deterministic composition, no model, one copy of the rows.
Problem Management on DODIL: Cluster Incidents, Root-Cause with a Gate, Publish a Known Error
Stop firefighting the same outage. Cluster recurring incidents by vector similarity over incidents.embedding, synthesise the root cause with a kimi-k2.6 gate, publish a known-error record, and link a change for the permanent fix — one DataK3 bucket, one Ignite engine over the incident/problem/change masters.
Run the SLA Clock on DODIL — Definitions, Per-Incident Breach Detection, and Escalation in Pure SQL
The deterministic half of ITSM: SLA policy as data (a per-priority response/resolve matrix), a per-incident clock that computes due dates and flags breaches the moment now() passes them, and an escalation log that routes a missed P1 to the group manager — all pure SQL over core.incidents on one DataK3 bucket. No model, no second system: the itsm-sla-monitor engine needs only k3.editor + ignite.app-developer, the provable no-Models path.
The Whole ITSM in One Bucket
A complete ITSM — CIs, incidents, problems, changes plus a CMDB blast-radius graph, SLA clocks, auto-triage, problem clustering, major-incident bridges and CAB change control — on ONE DataK3 bucket. Seven composable skills, shared master data joined across every workflow, one CMDB graph assembled once. 23 tables, no ETL, no second copy. This is the suite; each workflow is its own tutorial — and standing all seven up on one bucket is what found six integration bugs none of them could see alone.
General Ledger
9 tutorialsFinancial-Services GL on DODIL
The General Ledger suite, reshaped for a regulated SOX-style close — journals that carry a preparer, an approver and an approval state, an immutable approval trail, and a segregation-of-duties hard gate that blocks a self-approved journal from posting even when it balances. A period can't close while any journal in it is unapproved. It's the GL suite plus one additive overlay, on the same bucket.
Financial Statements on DODIL — a P&L and a Balance Sheet That Ties, Rolled Up Over the Account Graph
The two statements every close produces, from the ledger you already have: a period P&L (revenue − expense = net income) and a balance sheet that ties to the cent — assets = liabilities + equity + the un-closed current-period net income. Each statement line is rolled up by account type over the gl/core account-hierarchy graph (graph_khop from Total Revenue / Total Assets to its posting leaves), summed over one copy of the ledger rows, and materialized idempotently with INSERT … ON CONFLICT. Money is DECIMAL(18,2), and the sheet ties because the trial balance is 0.00 — double-entry, proven live. Two pillars, SQL and graph, one bucket.
Post a Balanced Journal to the Ledger — Exactly Once — on DODIL: the Balance Gate, Idempotent ON CONFLICT Posting, and Reversal
The General Ledger correctness showcase, live over the DataK3 pg wire: enforce the double-entry balance invariant BEFORE a journal posts (reject anything where debits do not equal credits), post it idempotently so a retry or shard replay lands ONCE (INSERT … ON CONFLICT (journal_id,line_no) DO UPDATE, never a bare re-INSERT that 23505s), reverse it with a mirror journal that nets the affected accounts back to zero, and keep an append-only journal_audit trail — all pure SQL over gl/core's journals / journal_lines / ledger on one bucket. Money is DECIMAL(18,2) so it never drifts; concurrent posters retry on SerializationFailure.
Multi-Currency FX Revaluation on DODIL — Exact, Balanced, and Reversible Unrealized Gain/Loss
Carry a foreign-currency bank balance and revalue it into your functional currency at the month-end rate — the way ASC 830 / IAS 21 require — on one DataK3 bucket. FX rates are DECIMAL(18,6) and money is DECIMAL(18,2), so the unrealized gain/loss lands to the exact cent (no float tail); the reval posts a balanced journal (SUM(debit) = SUM(credit)); and it auto-reverses next period so the two periods net to 0.00. Every write is idempotent — INSERT … ON CONFLICT DO UPDATE — and, the harder half, so is the computation: the reval re-derives its base excluding its own journals, so a re-run is a no-op instead of revaluing its own result. Pure SQL over the Postgres wire; consumes the gl/core masters.
Close an Accounting Period on DODIL — Trial Balance, an Immutable Period Lock, and Net Income Rolled to Retained Earnings in Pure SQL
Month-end close as three deterministic SQL moves over gl/core's journals and ledger on one DataK3 bucket: snapshot the per-account trial balance and prove the grand total nets to 0.00, lock the period so a late operational journal is rejected 409 the moment it tries to post into it — and say precisely what that lock does and does not cover, because DataK3 accepts a subquery CHECK and a FOREIGN KEY at DDL and never enforces either — and roll net income (Σrevenue − Σexpense) into retained earnings with a balanced closing journal that zeroes every P&L account. Money is DECIMAL(18,2), never a float; every write is idempotent (INSERT … ON CONFLICT DO UPDATE), so a re-close never double-rolls net income.
Reconcile an AP/AR Subledger to its GL Control Account on DODIL — a Cross-Table Tie-Out that Proves Variance 0.00
The control that catches an unrecorded liability before the auditor does: an AP/AR subledger (open bills and invoices carrying a control_account_id) tied out against its GL control account so the variance is provably 0.00 — a single cross-table JOIN over one DataK3 bucket. Money is DECIMAL(18,2), never a float, so a subledger of open items sums to the exact cent the ledger carries; every recompute is idempotent (INSERT … ON CONFLICT DO UPDATE), so the nightly tie-out re-runs without doubling a row; and the instant a bill lands in the subledger with no GL entry, the variance goes non-zero and the account is flagged. Pure SQL — no model in the loop.
The Whole General Ledger in One Bucket
A complete general ledger — chart of accounts, an account-hierarchy graph, balance-gated idempotent posting, period close, subledger reconciliation, multi-currency revaluation, and financial statements — on ONE DataK3 bucket. Six composable skills, shared masters joined across every workflow, one account graph assembled once. 14 tables, no ETL, no second copy. And the piece a stitched stack gets wrong: the multi-currency trial balance resolved correctly — post a EUR sale, watch the functional trial balance go off by exactly the unposted FX movement, revalue, watch it net back to 0.00.
Manufacturing GL on DODIL
The General Ledger suite, reshaped into a cost-accounting ledger — accounts that carry a cost center, an inventory / WIP / COGS / variance chart of accounts, and a standard-cost variance journal that books inventory at standard, routes the purchase-price variance to the P&L, and credits payables at actual. Every journal balances, inventory and WIP roll into the balance sheet, COGS and the variance roll into the P&L, and the trial balance stays 0.00. It's the GL suite plus one additive overlay, on the same bucket.
Scaffold the General Ledger Core on DODIL — Chart of Accounts, an Account-Hierarchy Graph, and Balanced Opening Balances
The system of record every GL workflow writes to: the chart of accounts, the account-hierarchy graph that rolls a leaf account up to Total Assets in one hop-ranked query, and the shared journals / journal_lines / ledger shapes — on one DataK3 bucket. Money is DECIMAL(18,2), never a float; every write is idempotent (INSERT … ON CONFLICT DO UPDATE); and one balanced opening-balance journal seeds the ledger so the trial balance nets to 0.00 from day one. One bucket, two pillars — SQL and graph — over one copy of the rows.
Procurement
1 tutorialHR
1 tutorialLegal/CLM
1 tutorialExpense
1 tutorialSupport
1 tutorialMDM / Customer-360
1 tutorialAI & Retrieval
6 tutorialsRAG & Agents
1 tutorialSemantic Cache
1 tutorialSIEM / Security
1 tutorialProduct Search
1 tutorialScientific Data
1 tutorialCode Intelligence
1 tutorialData & Analytics
2 tutorialsData Warehouse
2 tutorialsBuilding a Trading-Signal Warehouse: Batch-Analyze a Filings Firehose on DODIL
Stand up a DataK3 warehouse, source a multi-year filings backfill plus a daily news firehose into it, batch-analyze hundreds of thousands of documents on a low-cost model in parallel, then query structured signals with SQL, walk an issuer/sector/supply-chain graph to size blast radius, and search filings by meaning — all over one bucket.
Building a Leads Data Warehouse on DODIL: Enrich, Classify & Link 200k Orgs on Low-Cost Inference
Stand up a DataK3 warehouse, discover orgs into it, classify 200,000 companies on a low-cost model into a queryable organizations table, propagate ICP-fit across corporate families with a graph, dedup lookalikes with vectors, then open only the qualified into people — one bucket, three pillars.
Platform
5 tutorialsGetting Started
1 tutorialDrivers / Connect
1 tutorialApp Auth
2 tutorialsAuth Is Config, Not Code: End-User and Platform Sign-In for DODIL Apps
Every app you build on DODIL serves two kinds of caller: business users who log in (sales reps, customers, guests) and platform principals (service accounts, CI, other services) that call it machine-to-machine. On DODIL that is a config decision, not an auth library. Attach a dodil-appid pool to an Ignite app and the per-cluster gateway runs the whole browser login — PKCE S256, an AEAD-sealed host-only session cookie, single-flight refresh — then injects X-Dodil-User, X-Dodil-User-Jwt and X-Dodil-Auth-Source into your request. The app ships no auth code. Platform callers keep working alongside, because the model is additive. And when you are NOT behind that gateway, you verify the pool's EdDSA JWT yourself against its JWKS with iss AND aud mandatory.
Who-Can-Do-What Without a Policy Server: App Authorization on DODIL with dodil-appid
Your app on DODIL knows who the user is — now it needs to know what they can do. A rep sees only their deals; an approver can approve invoices. The usual answers are a policy server (OPA, a permissions microservice) you call on every request, or authz logic smeared through the app. dodil-appid does RBAC in the token: a per-pool role catalog maps roles to resource:action permissions, a user's roles expand into a permissions claim on their JWT, and the app checks permissions locally with zero round-trips. Behind the Ignite gateway that token arrives already verified in X-Dodil-User-Jwt, so the app reads permissions off an injected header and verifies nothing. Tenants add per-subsidiary roles and tenant-pinned tokens — the ERP layer. And the two-plane rule holds: appid says who and what-role; the app filters rows by sub via its own service account, because bucket RBAC can't do per-row authz.