Pluggable.
Philosophical.
Powerful.
A diagnostic analytics platform
that learns every domain it enters.
Almost none of them do it well.
Multiple source systems. Manual spreadsheets. Tribal knowledge.
The person who knows what “normal” looks like retires or changes roles.
Every new domain, every new industry — the same six-month discovery.
The tooling doesn't transfer. The expertise doesn't accumulate.
What if the platform learned
from every domain it entered?
- An engine that knows how to ingest, validate, diagnose, and present — for any domain.
- Domain packs that encode what to look for and why — all declarative, all swappable.
- AI that brings subject matter expertise on demand — new domain, new conversation.
- A compound effect where each deployment makes the next one faster and richer.
The Platform
Three verbs. Three stores. One continuous cycle.
Make. Desk. Console.
Build the KLS.
Validate everything.
Understand patterns.
Write the OPS.
Author new diagnostics.
Capture knowledge.
The loop closes by authoring — the console drafting a YAML
into the AFS, or the Atelier writing one straight from the desk.
Each turn produces a richer, more accurate analytical system.
jin make
Reads the AFS (YAML definitions, contracts) and the
delivered CSVs; writes the KLS. The security boundary.
Six compilers: signals, theses, verdicts,
Subject Matter, Dossiers, registry.
jin make acme.warehouse_east
Workspace isolation. Never mutates source files.
Deterministic. Same AFS commit + same CSVs → same KLS bytes.
Deployable anywhere. Laptop, CI, cloud function.
Multi-tenant. Each tenant is an isolated DuckDB schema.
jin desk
Browse dimensions, taxonomy hierarchies,
signal findings, thesis verdicts,
verdict root causes, expert knowledge.
Human-readable interpretations.
Multi-lingual (EN/DE/FR).
make.Writes the OPS. Notes, bookmarks, bell — operational state stays operational.
Desktop or web. macOS, Linux, Windows, browser.
Authors into the AFS via the Atelier — a signal written here changes what the next
make computes.Locale switching. Same data, different language.
jin console
Queries what make built.
Walks lineage from finding to source row.
Drafts new YAML straight into the AFS.
“Which entities drive the anomaly?”
“Write a signal for that pattern.”
Reads the KLS and the AFS. Writes the AFS.
Lands like a hand-authored one. Built by the next
make.Human confirms. AI proposes, human approves.
Tenant-isolated. AI sees only the assigned tenant.
The console drafts artefacts.
Make builds them. The desk reveals what changed.
new signal YAML
compile + build
see new findings
refine thresholds
Every turn through the cycle refines understanding.
The system gets smarter because the artifacts get better.
The Architecture
Three stores. Compilers. The analytical pyramid.
Every piece of state has a home
CSVs, YAML definitions,
contracts, tenant configs.
Version-controlled.
Separate from engine code.
Built product of make.
Medallion layers, findings,
verdicts, expert knowledge.
Read-only for desk and console.
Notes, bookmarks, bell
resolutions, scenarios.
Never rebuilt. It outlives
every KLS — restore, don’t regenerate.
Clear ownership. No ambiguity.
artifacts
reads AFS
writes KLS
database
reads KLS
writes OPS
database
reads KLS
writes AFS
artifacts
rebuilds
AFS is the input to make. KLS is the output.
The console reads the output and writes the input. The loop closes by
authoring — no arrow leaves the OPS.
Medallion architecture with a diagnostic layer
any ERP export
structural ingestion
validated + typed
consumption contract
signals + verdicts
Bronze = structure. Silver = domain truth. Gold = consumption contract.
No silent filtering — invalid rows are flagged, not dropped, until Gold.
Source-system dispatch happens only in Bronze.
From Silver onward, everything is source-system agnostic.
YAML in. SQL out. Six compilers.
From data signals to root causes
Each layer adds interpretation and business context.
Subject Matter floats alongside — expert knowledge anchored anywhere.
Every tenant is an isolated world
- Schema isolation. Each tenant is a DuckDB schema. Resettable independently. No data leakage.
- Source-system dispatch. Same domain pack handles multiple ERPs. Column mapping happens once, in Bronze.
- Platform layer. UNION ALL across tenants for cross-tenant analytics. Opt-in.
- AI isolation. When AI assists (the console, or Vera at the desk), it sees only its assigned tenant. Never cross-schema.
- Snapshot. Freeze any tenant's state as an immutable, self-describing DuckDB file. Audit-ready.
Domain Packs
The pluggable expertise layer.
The engine doesn't know what an “invoice” is.
The domain pack does.
Six YAML → SQL compilers
Findings contract (10 standard columns)
Taxonomy engine (tree + closure table)
JinDesk (discovery, interpretation, i18n)
Multi-tenant platform layer
Orchestration + rebuild scripts
Knows how. Knows nothing about why.
Source-system dispatch (column mappings)
Signal YAML definitions (business rules)
Thesis + Verdict YAMLs
Subject Matter + Dossiers
Registry (tri-lingual display text)
Interpretation rules
Knows why. All declarative. All swappable.
A directory. YAML and JSON. No code.
domain-name/
entity schemas
diagnostic rules
business questions
i18n + registry
Self-contained. Versioned. Declarative.
The engine discovers and loads it via a manifest file.
Swap the directory → swap the domain.
The diagnostic patterns are universal
- Balance signals — compare two aggregates per entity. Usage vs billing. Received vs sold. Ordered vs delivered.
- Duplicate detection — same shape everywhere. Duplicate invoices, duplicate shipments, duplicate purchase orders.
- Trend analysis — rolling average drift. Material costs, lead times, defect rates. The math is identical.
- Mandatory item — “this entity must have that child.” Safety cert with equipment. Inspection with asset. Signature with contract.
- Taxonomy hierarchies — cost centres, product categories, regional structures. Same closure table, different labels.
Signal types across domains
| Signal Type | Healthcare | Retail | Manufacturing |
|---|---|---|---|
| balance | Usage vs billed | Received vs sold | BOM vs actual |
| mandatory_item | Implant with surgery | Core assortment | QC cert with batch |
| trend | Cost drift per month | Margin erosion | Scrap rate trend |
| distribution_outlier | Case cost outlier | Return rate anomaly | Yield deviation |
| duplicate | Duplicate billing | Duplicate invoice | Duplicate shipment |
| perspective | Case integrity | Store health | Line efficiency |
The compiler generates identical SQL structures.
Only the entity names and thresholds change.
Material/resource flows + financial reconciliation
AI as Subject Matter Expert
The framework is the engineering. AI is the domain knowledge.
Three roles, not one
New domain = new conversation.
Same framework.
engine
domain knowledge
contracts + signals + i18n
Instance
To enter retail: ask AI about inventory schemas, shrinkage patterns,
planogram compliance, margin erosion — generate the domain pack.
To enter pharma: ask AI about batch records, LIMS formats,
yield calculations, GMP compliance — generate the domain pack.
The framework stays. The expertise is injected.
Each domain pack makes the platform
smarter for the next one.
- Domain 1 reveals that balance signals need interpretation rules — context-dependent severity. The engine gains the interpretation layer.
- Domain 2 reveals that trend signals need seasonal adjustment. The DSL gains a
seasonalmodifier. All domains benefit. - Each domain's calibrated thresholds inform the next. “What does normal look like?” gets answered by data, not guesswork.
- AI accumulates cross-domain patterns. The framework gets better at every domain because it's been to others.
The Business
Open engine. Expert domain packs. AI-powered growth.
Three revenue layers
Open or source-available.
Drives adoption and trust.
The platform. Free to evaluate.
regulatory context, calibrated thresholds.
Subscription per tenant.
The expertise. The revenue.
a domain pack for a new industry.
AI-accelerated. Weeks, not months.
The growth engine.
Four layers of defensibility
- Regulatory knowledge. Every domain has its legal landscape. The domain pack encodes it. Not easily reproduced.
- Calibrated thresholds. What does “normal” look like? You can't guess this. You earn it from production data.
- Interpretation rules. The difference between noise and signal. Context-dependent severity that turns raw findings into actionable insight.
- Source-system expertise. Every ERP has quirks. Column naming conventions, edge cases, undocumented behaviors. Earned through ingestion, not documentation.
What jinflow believes
- Domain agnosticism. jinflow knows about artifacts, compilers, tenants, and layers — not about invoices, batches, or shipments.
- Engine / content separation. The engine ships as a versioned package. Domain content lives in a separate git repo — the AFS.
- DuckDB as the universal contract. Make writes it. The desk reads it. The console queries it. No other shared state.
- Workspace isolation. Make never mutates source directories. Temp workspace → compile → build → output.
- Cloud readiness. Same Python library locally and in Lambda. Different callers, same engine.
Boring where it matters. Sharp where it counts.
analytical database
SQL models + tests
compilers + validators
desktop + web
console + authoring
The framework
that learns every domain
it enters.
Highly automated. Deeply interactive.
AI brings the expertise. The engine makes it actionable.
Each deployment makes the next one faster.
Pluggable. Philosophical. Powerful.