The Big Picture

Why jinflow exists

Organizations sit on data they don’t understand. Supply chains leak revenue. Ski resorts can’t reconcile ticket sales with lift rides. Freight forwarders lose visibility between checkpoints. Law firms bill hours they can’t trace.

The data exists. The questions exist. What’s missing is a systematic way to go from “something looks wrong” to “here’s why, and here’s what to do about it.”

jinflow is that system.

One thing upfront — setup is the analysis

The pack is a head start. The analysis is the work.

When you onboard a new tenant on top of an existing domain pack, jinflow hands you a Gold contract, extractors, twenty-odd signals, several theses, and a Subject Matter catalogue — a working framework, not a finished analysis. The work of fitting it to this tenant’s data, calibrating the signals, capturing the institutional knowledge, and writing the theses that matter here — that’s the analysis. Budget the first month for analytical work, not configuration.

We say this loud because (a) it’s true, and (b) the flexibility to do that work end-to-end is exactly what makes jinflow different from a SaaS dashboard. See Setup is the analysis for the full framing and The first weeks with a new tenant for the realistic walkthrough.

The idea

Declare what you want to detect. The engine does the rest.

You write a signal: “find cases where billing events are missing.” You write a thesis: “is this a systematic billing gap?” You write a verdict: “the billing trigger only fires on inpatient discharges.”

Each declaration compiles to SQL. Each SQL model runs against your data. Each result feeds the next layer. The output is a knowledge store — a single DuckDB file containing findings, verdicts, explanations, and expert knowledge. Browsable in JinDesk.

No custom code. No ad-hoc queries. No dashboards that answer one question and raise three more. A declarative pipeline that builds understanding.

The jinflow — the sentence, five names, one shape, one centre

Jinflow fosters Progress by gaining Understanding through Observations, Knowledge, and Data.

The sentence is the product, said once. It pairs with the surface tagline (“talk to your data, so it speaks to you”) — the analytical model and the marketing surface say the same thing.

Five names — and only five — for the parts of that shape: Observations (what we notice), Knowledge (what we know), Data (what the data says), Understanding (the resolution — findings + verdicts), and Progress (what we’ll do). Understanding sits at the centre: three names feed into it, one name draws from it. The three feeders develop in parallel — a tenant matures Observations, Knowledge, and Data concurrently.

Three feeders converging on Understanding. One forward arm to Progress. Drop any one of the five and the shape collapses — the model is held by all five. The full breakdown — how Data unfolds (Signal → Thesis → Verdict), how Observations carry Explanation and Contributing Factor, how Knowledge holds Subject Matter alongside activatable patterns, and how Progress chains forward — lives at The jinflow and The Noun Topology.

Two views: the River and the Garden

jinflow presents the same landscape in two complementary views — you don’t choose one; both are always there. The River is where data moves and gets processed: source CSVs flowing through Bronze → Silver → Gold, extraction runs, signal fires — everything the system is doing right now. The Garden is where insights are cultivated: signals, theses, verdicts, and Subject Matter laid out as a walkable diamond, plus notes and bookmarks that support human use.

River and Garden are simultaneously navigational views (the /river and /garden routes in JinDesk) and operational places (where the water actually flows, where the plants actually grow). Same nouns, both meanings. See Sense 42 — The Landscape for the full model, including the six-way split of what actually changes across the landscape — water, river-processing, garden tools, gardener’s field guide, garden-tending, and person-planted markers.

The River is data in motion. Ingest, validate, transform — from source CSVs through Bronze → Silver → Gold. The people who work along the River are engineers: they improve extractors, fix validation, add entities. Their focus is the flow itself and the quality of what it delivers.

The Garden is the analytical framework arranged in place. Signals, theses, verdicts, Subject Matter — a walkable diamond of instruments and expertise. The people who tend the Garden are analysts and consultants: they add signals, refine theses, capture domain knowledge. Their focus is the structure of what the instruments tell us.

Neither view blocks the other. Both evolve continuously. jinflow make renews both in one pass. jinflow evolve assists in either — debugging a data-quality issue or drafting a new verdict. The Entity + Contract is the seam where the River delivers into the Garden: the River guarantees the Entity’s shape and quality, the Garden trusts that guarantee.

	The River	The Garden
Who	Data engineer	Analyst, consultant, domain expert
Thinks in	SQL, schemas, data quality	Questions, theses, evidence
Writes	dbt models, source-system macros	Signals, theses, verdicts, Subject Matter
Meets at	Entity (Gold)	Entity (Gold)
Tools	jinflow make, dbt CLI	JinDesk, jinflow evolve, YAML editor

Both views reach for the same artifacts — Entity, Signal, Subject Matter, and the rest. The next section names them by which of the three inputs to Understanding they belong to.

Three inputs to Understanding

Every jinflow artifact contributes to one of three streams that converge on Understanding — or it’s shared substrate that serves all three. The three streams are the three feeders shown in the diamond above:

• Observations — what humans notice, signed by a named person. The narrative layer that carries Explanation and Contributing Factor. See Sense 15.
• Knowledge — what domain experts have codified. Subject Matter (Statement / Check) grouped into Dossiers. Pack-sourced and single-sourced.
• Data — what the analytical instruments say. Signals emit Findings, Perspectives aggregate, Theses evaluate, Verdicts judge. The instruments themselves ship in the pack as templates; the tenant imports and owns them.

Observations — what humans notice. An Observation is a named person’s signed notice about this tenant’s reality — bounded, dated, attributed. It carries an Explanation (why it happens) and one or more Contributing Factors (specific Findings or Verdicts that ground the narrative in the truth-bearing band). Validation attests that the Observation still holds. The signed human layer is Sense 15.

Knowledge — what experts have codified. Experts capture what they know about the domain itself: system quirks, process workarounds, mapping decisions. A Subject Matter entry is either a Statement (a claim about how the domain works) or a Check (a SQL-executable assertion). Dossiers group related Subject Matters into narratives. This layer is pack-sourced and single-sourced — tenants reference it; they never copy or fork it. “OPALE splits cases at midnight” is true wherever OPALE runs, so it belongs in the pack.

Data — what the analytical instruments say. The pack ships a catalog of templates — Signal, Perspective, Thesis, Verdict. A tenant imports a template and then owns it: once it hits real tenant data, it diverges and evolves locally. Imported Signals run on Gold entities and emit machine output — Findings, Perspective scores, Thesis status, Verdict output. That output is the tenant’s “what the data says.”

Shared substrate. The pack also contains much that serves all three streams but sits in none: dbt models, macros, extractors, contracts, tenant skeletons, welcome screens. Those are infrastructure — the River that delivers Gold, the plumbing that lets each stream reach Understanding.

Artifact	Stream	Pack role	Tenant role
Observation, Validation, Explanation, Contributing Factor	Observations	—	always (signed human · Sense 15)
Subject Matter, Statement, Check, Dossier	Knowledge	single source of truth	referenced, never copied
Signal, Perspective, Thesis, Verdict	Data	catalog of templates	imported, owned, evolves
Finding, Perspective score, Thesis status, Verdict output	Data	—	always (machine-computed)

Understanding is where the three converge, and Progress is what flows out. This is the sentence at the top of this page, said again in artifact terms.

The core loop

Make compiles your declarations and builds the knowledge store. Explore lets you browse findings, test theses, and review evidence in a web UI. Evolve connects you to Claude AI for deeper analysis. Each cycle deepens understanding.

Design principles

Declarative, not procedural. You declare what to detect. The engine decides how to compute it. Today the declarations are YAML compiled to SQL. Tomorrow it could be a different surface — the principle stays.

No silent filtering. Invalid data is flagged, not dropped. Every row carries an is_valid flag and an invalid_reason. Gold only shows valid rows, but Silver preserves everything. Nothing disappears without a trace.

Quality is queryable. Data quality isn’t a side report — it’s a first-class dbt model. You can query quality metrics the same way you query the data itself.

Knowledge as data. Expert knowledge (Subject Matter) lives in the same pipeline as findings. It’s attributed, versioned, scoped, and optionally testable. The difference between data and knowledge is the why.

Multi-tenant by design. Each tenant is an isolated DuckDB schema. Tenants share the analytical framework but never see each other’s data. The AI is scoped to exactly one tenant per session.

Domain packs power the analytics. Each pack bundles signal / thesis / verdict / perspective templates, Subject Matter, Dossiers, contracts, and source-system adapters for a specific industry. The engine is domain-agnostic — packs bring the domain expertise. Reference packs include nuMetrix, Millesime (winemaking), Alptrack (ski resorts), InterLogic (logistics), and more.

Who is jinflow for?

Role	Focus	What they do
Data engineer	The River	Maintains the medallion pipeline. Adds source-system adapters. Delivers clean Entities.
Consultant	The Garden	Builds signals and theses for clients. Packages expertise into domain packs.
Analyst	The Garden	Explores findings in JinDesk. Captures expert knowledge as Subject Matter.
Leadership	Consume the results	Reviews executive summaries, confirmed theses, and verdict root causes.

What makes jinflow different

From BI tools: BI dashboards answer predefined questions. jinflow discovers questions you didn’t know to ask — and explains why the answers matter.

From data quality tools: Quality tools flag bad data. jinflow detects patterns (signals), evaluates whether they’re systematic (theses), explains why they’re happening (verdicts), and recommends what to do.

From custom analytics: Custom code is powerful but fragile. jinflow provides a declarative framework where the analytical logic is versioned, compiled, and reproducible — not buried in notebooks or scripts.

Next steps

• Your First Build — build a signal and explore findings in 15 minutes
• Glossary — 54 terms explained
• Domain Packs — see what jinflow looks like across 4 industries